<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
<link rel="Start" href="index.html">
<link rel="previous" href="Stats.html">
<link rel="next" href="Formatcil.html">
<link rel="Up" href="index.html">
<link title="Index of types" rel=Appendix href="index_types.html">
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
<link title="Index of values" rel=Appendix href="index_values.html">
<link title="Index of class methods" rel=Appendix href="index_methods.html">
<link title="Index of classes" rel=Appendix href="index_classes.html">
<link title="Index of class types" rel=Appendix href="index_class_types.html">
<link title="Index of modules" rel=Appendix href="index_modules.html">
<link title="Index of module types" rel=Appendix href="index_module_types.html">
<link title="Pretty" rel="Chapter" href="Pretty.html">
<link title="Errormsg" rel="Chapter" href="Errormsg.html">
<link title="Clist" rel="Chapter" href="Clist.html">
<link title="Stats" rel="Chapter" href="Stats.html">
<link title="Cil" rel="Chapter" href="Cil.html">
<link title="Formatcil" rel="Chapter" href="Formatcil.html">
<link title="Alpha" rel="Chapter" href="Alpha.html">
<link title="Cillower" rel="Chapter" href="Cillower.html">
<link title="Cfg" rel="Chapter" href="Cfg.html">
<link title="Dataflow" rel="Chapter" href="Dataflow.html">
<link title="Dominators" rel="Chapter" href="Dominators.html"><title>CIL API Documentation (version 1.4.0) : Cil</title>
</head>
<body>
<div class="navbar"><a href="Stats.html">Previous</a>
&nbsp;<a href="index.html">Up</a>
&nbsp;<a href="Formatcil.html">Next</a>
</div>
<center><h1>Module <a href="type_Cil.html">Cil</a></h1></center>
<br>
<pre><span class="keyword">module</span> Cil: <code class="code">sig</code> <a href="Cil.html">..</a> <code class="code">end</code></pre><b>CIL API Documentation.</b>  An html version of this document 
  can be found at http://hal.cs.berkeley.edu/cil<br>
<hr width="100%">
<br>
<b>CIL API Documentation.</b>  An html version of this document 
  can be found at http://hal.cs.berkeley.edu/cil<br>
<pre><span id="VALinitCIL"><span class="keyword">val</span> initCIL</span> : <code class="type">unit -> unit</code></pre><div class="info">
Call this function to perform some initialization. Call if after you have 
 set <a href="Cil.html#VALmsvcMode"><code class="code">Cil.msvcMode</code></a>.<br>
</div>
<pre><span id="VALcilVersion"><span class="keyword">val</span> cilVersion</span> : <code class="type">string</code></pre><div class="info">
These are the CIL version numbers. A CIL version is a number of the form 
 M.m.r (major, minor and release)<br>
</div>
<pre><span id="VALcilVersionMajor"><span class="keyword">val</span> cilVersionMajor</span> : <code class="type">int</code></pre><pre><span id="VALcilVersionMinor"><span class="keyword">val</span> cilVersionMinor</span> : <code class="type">int</code></pre><pre><span id="VALcilVersionRevision"><span class="keyword">val</span> cilVersionRevision</span> : <code class="type">int</code></pre><br>
This module defines the abstract syntax of CIL. It also provides utility 
 functions for traversing the CIL data structures, and pretty-printing 
 them. The parser for both the GCC and MSVC front-ends can be invoked as 
 <code class="code">Frontc.parse: string -&gt; unit -&gt;</code> <a href="Cil.html#TYPEfile"><code class="code">Cil.file</code></a>. This function must be given 
 the name of a preprocessed C file and will return the top-level data 
 structure that describes a whole source file. By default the parsing and 
 elaboration into CIL is done as for GCC source. If you want to use MSVC 
 source you must set the <a href="Cil.html#VALmsvcMode"><code class="code">Cil.msvcMode</code></a> to <code class="code">true</code> and must also invoke the 
 function <code class="code">Frontc.setMSVCMode: unit -&gt; unit</code>.<br>
<br>
<b>The Abstract Syntax of CIL</b><br>
<br>
The top-level representation of a CIL source file (and the result of the 
 parsing and elaboration). Its main contents is the list of global 
 declarations and definitions. You can iterate over the globals in a 
 <a href="Cil.html#TYPEfile"><code class="code">Cil.file</code></a> using the following iterators: <a href="Cil.html#VALmapGlobals"><code class="code">Cil.mapGlobals</code></a>, 
 <a href="Cil.html#VALiterGlobals"><code class="code">Cil.iterGlobals</code></a> and <a href="Cil.html#VALfoldGlobals"><code class="code">Cil.foldGlobals</code></a>. You can also use the 
 <a href="Cil.html#VALdummyFile"><code class="code">Cil.dummyFile</code></a> when you need a <a href="Cil.html#TYPEfile"><code class="code">Cil.file</code></a> as a placeholder. For each 
 global item CIL stores the source location where it appears (using the 
 type <a href="Cil.html#TYPElocation"><code class="code">Cil.location</code></a>)<br>
<br><code><span id="TYPEfile"><span class="keyword">type</span> <code class="type"></code>file</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>fileName&nbsp;: <code class="type">string</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The complete file name</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>globals&nbsp;: <code class="type"><a href="Cil.html#TYPEglobal">global</a> list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >List of globals as they will appear 
                                        in the printed file</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>globinit&nbsp;: <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> option</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >An optional global initializer function. This is a function where 
 you can put stuff that must be executed before the program is 
 started. This function is conceptually at the end of the file, 
 although it is not part of the globals list. Use <a href="Cil.html#VALgetGlobInit"><code class="code">Cil.getGlobInit</code></a> 
 to create/get one.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>globinitcalled&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Whether the global initialization function is called in main. This 
 should always be false if there is no global initializer. When you 
 create a global initialization CIL will try to insert code in main 
 to call it. This will not happen if your file does not contain a 
 function called "main"</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
Top-level representation of a C source file<br>
</div>

<pre><span id="TYPEcomment"><span class="keyword">type</span> <code class="type"></code>comment</span> = <code class="type"><a href="Cil.html#TYPElocation">location</a> * string</code> </pre>

<br>
<b>Globals</b>. The main type for representing global declarations and 
 definitions. A list of these form a CIL file. The order of globals in the 
 file is generally important.<br>
<br><code><span id="TYPEglobal"><span class="keyword">type</span> <code class="type"></code>global</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GType</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtypeinfo">typeinfo</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A typedef. All uses of type names (through the <code class="code">TNamed</code> constructor) 
        must be preceded in the file by a definition of the name. The string 
        is the defined name and always not-empty.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GCompTag</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEcompinfo">compinfo</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Defines a struct/union tag with some fields. There must be one of 
        these for each struct/union tag that you use (through the <code class="code">TComp</code> 
        constructor) since this is the only context in which the fields are 
        printed. Consequently nested structure tag definitions must be 
        broken into individual definitions with the innermost structure 
        defined first.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GCompTagDecl</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEcompinfo">compinfo</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Declares a struct/union tag. Use as a forward declaration. This is 
 printed without the fields.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GEnumTag</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEenuminfo">enuminfo</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Declares an enumeration tag with some fields. There must be one of 
      these for each enumeration tag that you use (through the <code class="code">TEnum</code> 
      constructor) since this is the only context in which the items are 
      printed.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GEnumTagDecl</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEenuminfo">enuminfo</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Declares an enumeration tag. Use as a forward declaration. This is 
 printed without the items.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GVarDecl</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEvarinfo">varinfo</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A variable declaration (not a definition). If the variable has a 
       function type then this is a prototype. There can be several 
       declarations and at most one definition for a given variable. If both 
       forms appear then they must share the same varinfo structure. A 
       prototype shares the varinfo with the fundec of the definition. Either 
       has storage Extern or there must be a definition in this file</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GVar</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEvarinfo">varinfo</a> * <a href="Cil.html#TYPEinitinfo">initinfo</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A variable definition. Can have an initializer. The initializer is 
 updateable so that you can change it without requiring to recreate 
 the list of globals. There can be at most one definition for a 
 variable in an entire program. Cannot have storage Extern or function 
 type.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GFun</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A function definition.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GAsm</span> <span class="keyword">of</span> <code class="type">string * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Global asm statement. These ones 
                                            can contain only a template</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GPragma</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattribute">attribute</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Pragmas at top level. Use the same 
                                            syntax as attributes</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">GText</span> <span class="keyword">of</span> <code class="type">string</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Some text (printed verbatim) at 
                                            top level. E.g., this way you can 
                                            put comments in the output.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
A global declaration or definition<br>
</div>

<br>
<b>Types</b>. A C type is represented in CIL using the type <a href="Cil.html#TYPEtyp"><code class="code">Cil.typ</code></a>. 
 Among types we differentiate the integral types (with different kinds 
 denoting the sign and precision), floating point types, enumeration types, 
 array and pointer types, and function types. Every type is associated with 
 a list of attributes, which are always kept in sorted order. Use 
 <a href="Cil.html#VALaddAttribute"><code class="code">Cil.addAttribute</code></a> and <a href="Cil.html#VALaddAttributes"><code class="code">Cil.addAttributes</code></a> to construct list of 
 attributes. If you want to inspect a type, you should use 
 <a href="Cil.html#VALunrollType"><code class="code">Cil.unrollType</code></a> or <a href="Cil.html#VALunrollTypeDeep"><code class="code">Cil.unrollTypeDeep</code></a> to see through the uses of 
 named types.<br>
<br>
CIL is configured at build-time with the sizes and alignments of the 
 underlying compiler (GCC or MSVC). CIL contains functions that can compute 
 the size of a type (in bits) <a href="Cil.html#VALbitsSizeOf"><code class="code">Cil.bitsSizeOf</code></a>, the alignment of a type 
 (in bytes) <a href="Cil.html#VALalignOf_int"><code class="code">Cil.alignOf_int</code></a>, and can convert an offset into a start and 
 width (both in bits) using the function <a href="Cil.html#VALbitsOffset"><code class="code">Cil.bitsOffset</code></a>. At the moment 
 these functions do not take into account the <code class="code">packed</code> attributes and 
 pragmas.<br>
<br><code><span id="TYPEtyp"><span class="keyword">type</span> <code class="type"></code>typ</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TVoid</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattributes">attributes</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Void type. Also predefined as <a href="Cil.html#VALvoidType"><code class="code">Cil.voidType</code></a></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TInt</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEikind">ikind</a> * <a href="Cil.html#TYPEattributes">attributes</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >An integer type. The kind specifies the sign and width. Several 
 useful variants are predefined as <a href="Cil.html#VALintType"><code class="code">Cil.intType</code></a>, <a href="Cil.html#VALuintType"><code class="code">Cil.uintType</code></a>, 
 <a href="Cil.html#VALlongType"><code class="code">Cil.longType</code></a>, <a href="Cil.html#VALcharType"><code class="code">Cil.charType</code></a>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TFloat</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEfkind">fkind</a> * <a href="Cil.html#TYPEattributes">attributes</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A floating-point type. The kind specifies the precision. You can 
 also use the predefined constant <a href="Cil.html#VALdoubleType"><code class="code">Cil.doubleType</code></a>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TPtr</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEattributes">attributes</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Pointer type. Several useful variants are predefined as 
 <a href="Cil.html#VALcharPtrType"><code class="code">Cil.charPtrType</code></a>, <a href="Cil.html#VALcharConstPtrType"><code class="code">Cil.charConstPtrType</code></a> (pointer to a 
 constant character), <a href="Cil.html#VALvoidPtrType"><code class="code">Cil.voidPtrType</code></a>, 
 <a href="Cil.html#VALintPtrType"><code class="code">Cil.intPtrType</code></a></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TArray</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEexp">exp</a> option * <a href="Cil.html#TYPEattributes">attributes</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Array type. It indicates the base type and the array length.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TFun</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a> * (string * <a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEattributes">attributes</a>) list option * bool<br>        * <a href="Cil.html#TYPEattributes">attributes</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Function type. Indicates the type of the result, the name, type 
 and name attributes of the formal arguments (<code class="code">None</code> if no 
 arguments were specified, as in a function whose definition or 
 prototype we have not seen; <code class="code">Some []</code> means void). Use 
 <a href="Cil.html#VALargsToList"><code class="code">Cil.argsToList</code></a> to obtain a list of arguments. The boolean 
 indicates if it is a variable-argument function. If this is the 
 type of a varinfo for which we have a function declaration then 
 the information for the formals must match that in the 
 function's sformals. Use <a href="Cil.html#VALsetFormals"><code class="code">Cil.setFormals</code></a>, or 
 <a href="Cil.html#VALsetFunctionType"><code class="code">Cil.setFunctionType</code></a>, or <a href="Cil.html#VALmakeFormalVar"><code class="code">Cil.makeFormalVar</code></a> for this 
 purpose.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TNamed</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtypeinfo">typeinfo</a> * <a href="Cil.html#TYPEattributes">attributes</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The use of a named type. Each such type name must be preceded 
 in the file by a <code class="code">GType</code> global. This is printed as just the 
 type name. The actual referred type is not printed here and is 
 carried only to simplify processing. To see through a sequence 
 of named type references, use <a href="Cil.html#VALunrollType"><code class="code">Cil.unrollType</code></a> or 
 <a href="Cil.html#VALunrollTypeDeep"><code class="code">Cil.unrollTypeDeep</code></a>. The attributes are in addition to those 
 given when the type name was defined.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TComp</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEcompinfo">compinfo</a> * <a href="Cil.html#TYPEattributes">attributes</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The most delicate issue for C types is that recursion that is possible by 
 using structures and pointers. To address this issue we have a more 
 complex representation for structured types (struct and union). Each such 
 type is represented using the <a href="Cil.html#TYPEcompinfo"><code class="code">Cil.compinfo</code></a> type. For each composite 
 type the <a href="Cil.html#TYPEcompinfo"><code class="code">Cil.compinfo</code></a> structure must be declared at top level using 
 <code class="code">GCompTag</code> and all references to it must share the same copy of the 
 structure. The attributes given are those pertaining to this use of the 
 type and are in addition to the attributes that were given at the 
 definition of the type and which are stored in the <a href="Cil.html#TYPEcompinfo"><code class="code">Cil.compinfo</code></a>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TEnum</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEenuminfo">enuminfo</a> * <a href="Cil.html#TYPEattributes">attributes</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A reference to an enumeration type. All such references must
               share the enuminfo among them and with a <code class="code">GEnumTag</code> global that 
               precedes all uses. The attributes refer to this use of the 
               enumeration and are in addition to the attributes of the 
               enumeration itself, which are stored inside the enuminfo</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TBuiltin_va_list</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattributes">attributes</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >This is the same as the gcc's type with the same name</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>


<br>
There are a number of functions for querying the kind of a type. These are
 <a href="Cil.html#VALisIntegralType"><code class="code">Cil.isIntegralType</code></a>, 
 <a href="Cil.html#VALisArithmeticType"><code class="code">Cil.isArithmeticType</code></a>, 
 <a href="Cil.html#VALisPointerType"><code class="code">Cil.isPointerType</code></a>, 
 <a href="Cil.html#VALisScalarType"><code class="code">Cil.isScalarType</code></a>, 
 <a href="Cil.html#VALisFunctionType"><code class="code">Cil.isFunctionType</code></a>, 
 <a href="Cil.html#VALisArrayType"><code class="code">Cil.isArrayType</code></a>. 
<p>

 There are two easy ways to scan a type. First, you can use the
<a href="Cil.html#VALexistsType"><code class="code">Cil.existsType</code></a> to return a boolean answer about a type. This function
is controlled by a user-provided function that is queried for each type that is
used to construct the current type. The function can specify whether to
terminate the scan with a boolean result or to continue the scan for the
nested types. 
<p>

 The other method for scanning types is provided by the visitor interface (see
 <a href="Cil.cilVisitor-c.html"><code class="code">Cil.cilVisitor</code></a>).
<p>

 If you want to compare types (or to use them as hash-values) then you should
use instead type signatures (represented as <a href="Cil.html#TYPEtypsig"><code class="code">Cil.typsig</code></a>). These
contain the same information as types but canonicalized such that simple Ocaml
structural equality will tell whether two types are equal. Use
<a href="Cil.html#VALtypeSig"><code class="code">Cil.typeSig</code></a> to compute the signature of a type. If you want to ignore
certain type attributes then use <a href="Cil.html#VALtypeSigWithAttrs"><code class="code">Cil.typeSigWithAttrs</code></a>.<br>
<br><code><span id="TYPEikind"><span class="keyword">type</span> <code class="type"></code>ikind</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">IChar</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">char</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ISChar</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">signed char</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">IUChar</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">unsigned char</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">IBool</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">_Bool (C99)</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">IInt</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">int</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">IUInt</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">unsigned int</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">IShort</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">short</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">IUShort</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">unsigned short</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ILong</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">long</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">IULong</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">unsigned long</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ILongLong</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">long long</code> (or <code class="code">_int64</code> on Microsoft Visual C)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">IULongLong</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">unsigned long long</code> (or <code class="code">unsigned _int64</code> on Microsoft 
                    Visual C)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Various kinds of integers<br>
</div>

<br><code><span id="TYPEfkind"><span class="keyword">type</span> <code class="type"></code>fkind</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FFloat</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">float</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FDouble</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">double</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FLongDouble</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" ><code class="code">long double</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Various kinds of floating-point numbers<br>
</div>

<br>
<b>Attributes.</b><br>
<br><code><span id="TYPEattribute"><span class="keyword">type</span> <code class="type"></code>attribute</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Attr</span> <span class="keyword">of</span> <code class="type">string * <a href="Cil.html#TYPEattrparam">attrparam</a> list</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >An attribute has a name and some optional parameters. The name should not 
 start or end with underscore. When CIL parses attribute names it will 
 strip leading and ending underscores (to ensure that the multitude of GCC 
 attributes such as const, __const and __const__ all mean the same thing.)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>


<pre><span id="TYPEattributes"><span class="keyword">type</span> <code class="type"></code>attributes</span> = <code class="type"><a href="Cil.html#TYPEattribute">attribute</a> list</code> </pre>
<div class="info">
Attributes are lists sorted by the attribute name. Use the functions 
 <a href="Cil.html#VALaddAttribute"><code class="code">Cil.addAttribute</code></a> and <a href="Cil.html#VALaddAttributes"><code class="code">Cil.addAttributes</code></a> to insert attributes in an 
 attribute list and maintain the sortedness.<br>
</div>

<br><code><span id="TYPEattrparam"><span class="keyword">type</span> <code class="type"></code>attrparam</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AInt</span> <span class="keyword">of</span> <code class="type">int</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >An integer constant</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AStr</span> <span class="keyword">of</span> <code class="type">string</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A string constant</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ACons</span> <span class="keyword">of</span> <code class="type">string * <a href="Cil.html#TYPEattrparam">attrparam</a> list</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Constructed attributes. These 
                                             are printed <code class="code">foo(a1,a2,...,an)</code>. 
                                             The list of parameters can be 
                                             empty and in that case the 
                                             parentheses are not printed.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ASizeOf</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A way to talk about types</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ASizeOfE</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattrparam">attrparam</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ASizeOfS</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtypsig">typsig</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Replacement for ASizeOf in type
                                             signatures.  Only used for
                                             attributes inside typsigs.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AAlignOf</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AAlignOfE</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattrparam">attrparam</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AAlignOfS</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtypsig">typsig</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AUnOp</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEunop">unop</a> * <a href="Cil.html#TYPEattrparam">attrparam</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ABinOp</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEbinop">binop</a> * <a href="Cil.html#TYPEattrparam">attrparam</a> * <a href="Cil.html#TYPEattrparam">attrparam</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ADot</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattrparam">attrparam</a> * string</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >a.foo *</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AStar</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattrparam">attrparam</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" > a</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AAddrOf</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattrparam">attrparam</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >&amp; a *</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AIndex</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattrparam">attrparam</a> * <a href="Cil.html#TYPEattrparam">attrparam</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >a1<code class="code">a2</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AQuestion</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattrparam">attrparam</a> * <a href="Cil.html#TYPEattrparam">attrparam</a> * <a href="Cil.html#TYPEattrparam">attrparam</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >a1 ? a2 : a3 *</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
The type of parameters of attributes<br>
</div>

<br>
<b>Structures.</b> The <a href="Cil.html#TYPEcompinfo"><code class="code">Cil.compinfo</code></a> describes the definition of a 
 structure or union type. Each such <a href="Cil.html#TYPEcompinfo"><code class="code">Cil.compinfo</code></a> must be defined at the 
 top-level using the <code class="code">GCompTag</code> constructor and must be shared by all 
 references to this type (using either the <code class="code">TComp</code> type constructor or from 
 the definition of the fields. 
<p>

   If all you need is to scan the definition of each 
 composite type once, you can do that by scanning all top-level <code class="code">GCompTag</code>. 
<p>

 Constructing a <a href="Cil.html#TYPEcompinfo"><code class="code">Cil.compinfo</code></a> can be tricky since it must contain fields 
 that might refer to the host <a href="Cil.html#TYPEcompinfo"><code class="code">Cil.compinfo</code></a> and furthermore the type of 
 the field might need to refer to the <a href="Cil.html#TYPEcompinfo"><code class="code">Cil.compinfo</code></a> for recursive types. 
 Use the <a href="Cil.html#VALmkCompInfo"><code class="code">Cil.mkCompInfo</code></a> function to create a <a href="Cil.html#TYPEcompinfo"><code class="code">Cil.compinfo</code></a>. You can 
 easily fetch the <a href="Cil.html#TYPEfieldinfo"><code class="code">Cil.fieldinfo</code></a> for a given field in a structure with 
 <a href="Cil.html#VALgetCompField"><code class="code">Cil.getCompField</code></a>.<br>
<br><code><span id="TYPEcompinfo"><span class="keyword">type</span> <code class="type"></code>compinfo</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>cstruct&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >True if struct, False if union</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>cname&nbsp;: <code class="type">string</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The name. Always non-empty. Use <a href="Cil.html#VALcompFullName"><code class="code">Cil.compFullName</code></a> to get the full 
 name of a comp (along with the struct or union)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>ckey&nbsp;: <code class="type">int</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A unique integer. This is assigned by <a href="Cil.html#VALmkCompInfo"><code class="code">Cil.mkCompInfo</code></a> using a 
 global variable in the Cil module. Thus two identical structs in two 
 different files might have different keys. Use <a href="Cil.html#VALcopyCompInfo"><code class="code">Cil.copyCompInfo</code></a> to 
 copy structures so that a new key is assigned.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>cfields&nbsp;: <code class="type"><a href="Cil.html#TYPEfieldinfo">fieldinfo</a> list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Information about the fields. Notice that each fieldinfo has a 
 pointer back to the host compinfo. This means that you should not 
 share fieldinfo's between two compinfo's</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>cattr&nbsp;: <code class="type"><a href="Cil.html#TYPEattributes">attributes</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The attributes that are defined at the same time as the composite 
 type. These attributes can be supplemented individually at each 
 reference to this <code class="code">compinfo</code> using the <code class="code">TComp</code> type constructor.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>cdefined&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >This boolean flag can be used to distinguish between structures
     that have not been defined and those that have been defined but have
     no fields (such things are allowed in gcc).</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>creferenced&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >True if used. Initially set to false.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
The definition of a structure or union type. Use <a href="Cil.html#VALmkCompInfo"><code class="code">Cil.mkCompInfo</code></a> to 
 make one and use <a href="Cil.html#VALcopyCompInfo"><code class="code">Cil.copyCompInfo</code></a> to copy one (this ensures that a new 
 key is assigned and that the fields have the right pointers to parents.).<br>
</div>

<br>
<b>Structure fields.</b> The <a href="Cil.html#TYPEfieldinfo"><code class="code">Cil.fieldinfo</code></a> structure is used to describe 
 a structure or union field. Fields, just like variables, can have 
 attributes associated with the field itself or associated with the type of 
 the field (stored along with the type of the field).<br>
<br><code><span id="TYPEfieldinfo"><span class="keyword">type</span> <code class="type"></code>fieldinfo</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>fcomp&nbsp;: <code class="type"><a href="Cil.html#TYPEcompinfo">compinfo</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The host structure that contains this field. There can be only one 
 <code class="code">compinfo</code> that contains the field.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>fname&nbsp;: <code class="type">string</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The name of the field. Might be the value of <a href="Cil.html#VALmissingFieldName"><code class="code">Cil.missingFieldName</code></a> 
 in which case it must be a bitfield and is not printed and it does not 
 participate in initialization</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>ftype&nbsp;: <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The type</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>fbitfield&nbsp;: <code class="type">int option</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >If a bitfield then ftype should be an integer type and the width of 
 the bitfield must be 0 or a positive integer smaller or equal to the 
 width of the integer type. A field of width 0 is used in C to control 
 the alignment of fields.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>fattr&nbsp;: <code class="type"><a href="Cil.html#TYPEattributes">attributes</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The attributes for this field (not for its type)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>floc&nbsp;: <code class="type"><a href="Cil.html#TYPElocation">location</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The location where this field is defined</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
Information about a struct/union field<br>
</div>

<br>
<b>Enumerations.</b> Information about an enumeration. This is shared by all 
 references to an enumeration. Make sure you have a <code class="code">GEnumTag</code> for each of 
 of these.<br>
<br><code><span id="TYPEenuminfo"><span class="keyword">type</span> <code class="type"></code>enuminfo</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>ename&nbsp;: <code class="type">string</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The name. Always non-empty.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>eitems&nbsp;: <code class="type">(string * <a href="Cil.html#TYPEexp">exp</a> * <a href="Cil.html#TYPElocation">location</a>) list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Items with names and values. This list should be non-empty. The item 
 values must be compile-time constants.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>eattr&nbsp;: <code class="type"><a href="Cil.html#TYPEattributes">attributes</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The attributes that are defined at the same time as the enumeration 
 type. These attributes can be supplemented individually at each 
 reference to this <code class="code">enuminfo</code> using the <code class="code">TEnum</code> type constructor.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>ereferenced&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >True if used. Initially set to false</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>ekind&nbsp;: <code class="type"><a href="Cil.html#TYPEikind">ikind</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The integer kind used to represent this enum. Per ANSI-C, this
 should always be IInt, but gcc allows other integer kinds</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
Information about an enumeration<br>
</div>

<br>
<b>Enumerations.</b> Information about an enumeration. This is shared by all 
 references to an enumeration. Make sure you have a <code class="code">GEnumTag</code> for each of 
 of these.<br>
<br><code><span id="TYPEtypeinfo"><span class="keyword">type</span> <code class="type"></code>typeinfo</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>tname&nbsp;: <code class="type">string</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The name. Can be empty only in a <code class="code">GType</code> when introducing a composite 
 or enumeration tag. If empty cannot be referred to from the file</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>ttype&nbsp;: <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The actual type. This includes the attributes that were present in 
 the typedef</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>treferenced&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >True if used. Initially set to false</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
Information about a defined type<br>
</div>

<br>
<b>Variables.</b> 
 Each local or global variable is represented by a unique <a href="Cil.html#TYPEvarinfo"><code class="code">Cil.varinfo</code></a>
structure. A global <a href="Cil.html#TYPEvarinfo"><code class="code">Cil.varinfo</code></a> can be introduced with the <code class="code">GVarDecl</code> or
<code class="code">GVar</code> or <code class="code">GFun</code> globals. A local varinfo can be introduced as part of a
function definition <a href="Cil.html#TYPEfundec"><code class="code">Cil.fundec</code></a>. 
<p>

 All references to a given global or local variable must refer to the same
copy of the <code class="code">varinfo</code>. Each <code class="code">varinfo</code> has a globally unique identifier that 
can be used to index maps and hashtables (the name can also be used for this 
purpose, except for locals from different functions). This identifier is 
constructor using a global counter.
<p>

 It is very important that you construct <code class="code">varinfo</code> structures using only one
 of the following functions:<ul>
<li><a href="Cil.html#VALmakeGlobalVar"><code class="code">Cil.makeGlobalVar</code></a> : to make a global variable</li>
<li><a href="Cil.html#VALmakeTempVar"><code class="code">Cil.makeTempVar</code></a> : to make a temporary local variable whose name
will be generated so that to avoid conflict with other locals. </li>
<li><a href="Cil.html#VALmakeLocalVar"><code class="code">Cil.makeLocalVar</code></a> : like <a href="Cil.html#VALmakeTempVar"><code class="code">Cil.makeTempVar</code></a> but you can specify the
exact name to be used. </li>
<li><a href="Cil.html#VALcopyVarinfo"><code class="code">Cil.copyVarinfo</code></a>: make a shallow copy of a varinfo assigning a new name 
and a new unique identifier</li>
</ul>

 A <code class="code">varinfo</code> is also used in a function type to denote the list of formals.<br>
<br><code><span id="TYPEvarinfo"><span class="keyword">type</span> <code class="type"></code>varinfo</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vname&nbsp;: <code class="type">string</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The name of the variable. Cannot be empty. It is primarily your 
 responsibility to ensure the uniqueness of a variable name. For local 
 variables <a href="Cil.html#VALmakeTempVar"><code class="code">Cil.makeTempVar</code></a> helps you ensure that the name is unique.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vtype&nbsp;: <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The declared type of the variable.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vattr&nbsp;: <code class="type"><a href="Cil.html#TYPEattributes">attributes</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A list of attributes associated with the variable.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vstorage&nbsp;: <code class="type"><a href="Cil.html#TYPEstorage">storage</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The storage-class</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vglob&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >True if this is a global variable</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vinline&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Whether this varinfo is for an inline function.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vdecl&nbsp;: <code class="type"><a href="Cil.html#TYPElocation">location</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Location of variable declaration.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vid&nbsp;: <code class="type">int</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A unique integer identifier. This field will be 
 set for you if you use one of the <a href="Cil.html#VALmakeFormalVar"><code class="code">Cil.makeFormalVar</code></a>, 
 <a href="Cil.html#VALmakeLocalVar"><code class="code">Cil.makeLocalVar</code></a>, <a href="Cil.html#VALmakeTempVar"><code class="code">Cil.makeTempVar</code></a>, <a href="Cil.html#VALmakeGlobalVar"><code class="code">Cil.makeGlobalVar</code></a>, or 
 <a href="Cil.html#VALcopyVarinfo"><code class="code">Cil.copyVarinfo</code></a>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vaddrof&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >True if the address of this variable is taken. CIL will set these 
 flags when it parses C, but you should make sure to set the flag 
 whenever your transformation create <code class="code">AddrOf</code> expression.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vreferenced&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >True if this variable is ever referenced. This is computed by 
 <code class="code">Rmtmps.removeUnusedTemps</code>. It is safe to just initialize this to False</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vdescr&nbsp;: <code class="type"><a href="Pretty.html#TYPEdoc">Pretty.doc</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >For most temporary variables, a description of what the var holds.
  (e.g. for temporaries used for function call results, this string
   is a representation of the function call.)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>vdescrpure&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Indicates whether the vdescr above is a pure expression or call.
  Printing a non-pure vdescr more than once may yield incorrect
  results.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
Information about a variable.<br>
</div>

<br><code><span id="TYPEstorage"><span class="keyword">type</span> <code class="type"></code>storage</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">NoStorage</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The default storage. Nothing is printed</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Static</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Register</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Extern</span></code></td>

</tr></table>

<div class="info">
Storage-class information<br>
</div>

<br>
<b>Expressions.</b> The CIL expression language contains only the side-effect free expressions of
C. They are represented as the type <a href="Cil.html#TYPEexp"><code class="code">Cil.exp</code></a>. There are several
interesting aspects of CIL expressions: 
<p>

 Integer and floating point constants can carry their textual representation.
This way the integer 15 can be printed as 0xF if that is how it occurred in the
source. 
<p>

 CIL uses 64 bits to represent the integer constants and also stores the width
of the integer type. Care must be taken to ensure that the constant is
representable with the given width. Use the functions <a href="Cil.html#VALkinteger"><code class="code">Cil.kinteger</code></a>,
<a href="Cil.html#VALkinteger64"><code class="code">Cil.kinteger64</code></a> and <a href="Cil.html#VALinteger"><code class="code">Cil.integer</code></a> to construct constant
expressions. CIL predefines the constants <a href="Cil.html#VALzero"><code class="code">Cil.zero</code></a>,
<a href="Cil.html#VALone"><code class="code">Cil.one</code></a> and <a href="Cil.html#VALmone"><code class="code">Cil.mone</code></a> (for -1). 
<p>

 Use the functions <a href="Cil.html#VALisConstant"><code class="code">Cil.isConstant</code></a> and <a href="Cil.html#VALisInteger"><code class="code">Cil.isInteger</code></a> to test if
an expression is a constant and a constant integer respectively.
<p>

 CIL keeps the type of all unary and binary expressions. You can think of that
type qualifying the operator. Furthermore there are different operators for
arithmetic and comparisons on arithmetic types and on pointers. 
<p>

 Another unusual aspect of CIL is that the implicit conversion between an
expression of array type and one of pointer type is made explicit, using the
<code class="code">StartOf</code> expression constructor (which is not printed). If you apply the
<code class="code">AddrOf}</code>constructor to an lvalue of type <code class="code">T</code> then you will be getting an
expression of type <code class="code">TPtr(T)</code>.
<p>

 You can find the type of an expression with <a href="Cil.html#VALtypeOf"><code class="code">Cil.typeOf</code></a>. 
<p>

 You can perform constant folding on expressions using the function
<a href="Cil.html#VALconstFold"><code class="code">Cil.constFold</code></a>.<br>
<br><code><span id="TYPEexp"><span class="keyword">type</span> <code class="type"></code>exp</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Const</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEconstant">constant</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Constant</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Lval</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPElval">lval</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Lvalue</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">SizeOf</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >sizeof(&lt;type&gt;). Has <code class="code">unsigned int</code> type (ISO 6.5.3.4). This is not 
 turned into a constant because some transformations might want to 
 change types</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">SizeOfE</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >sizeof(&lt;expression&gt;)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">SizeOfStr</span> <span class="keyword">of</span> <code class="type">string</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >sizeof(string_literal). We separate this case out because this is the 
 only instance in which a string literal should not be treated as 
 having type pointer to character.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AlignOf</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >This corresponds to the GCC __alignof_. Has <code class="code">unsigned int</code> type</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AlignOfE</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">UnOp</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEunop">unop</a> * <a href="Cil.html#TYPEexp">exp</a> * <a href="Cil.html#TYPEtyp">typ</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Unary operation. Includes the type of the result.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">BinOp</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEbinop">binop</a> * <a href="Cil.html#TYPEexp">exp</a> * <a href="Cil.html#TYPEexp">exp</a> * <a href="Cil.html#TYPEtyp">typ</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Binary operation. Includes the type of the result. The arithmetic 
 conversions are made explicit for the arguments.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">CastE</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEexp">exp</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Use <a href="Cil.html#VALmkCast"><code class="code">Cil.mkCast</code></a> to make casts.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AddrOf</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPElval">lval</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Always use <a href="Cil.html#VALmkAddrOf"><code class="code">Cil.mkAddrOf</code></a> to construct one of these. Apply to an 
 lvalue of type <code class="code">T</code> yields an expression of type <code class="code">TPtr(T)</code>. Use 
 <a href="Cil.html#VALmkAddrOrStartOf"><code class="code">Cil.mkAddrOrStartOf</code></a> to make one of these if you are not sure which 
 one to use.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">StartOf</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPElval">lval</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Conversion from an array to a pointer to the beginning of the array. 
 Given an lval of type <code class="code">TArray(T)</code> produces an expression of type 
 <code class="code">TPtr(T)</code>. Use <a href="Cil.html#VALmkAddrOrStartOf"><code class="code">Cil.mkAddrOrStartOf</code></a> to make one of these if you are 
 not sure which one to use. In C this operation is implicit, the 
 <code class="code">StartOf</code> operator is not printed. We have it in CIL because it makes 
 the typing rules simpler.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Expressions (Side-effect free)<br>
</div>

<br>
<b>Constants.</b><br>
<br><code><span id="TYPEconstant"><span class="keyword">type</span> <code class="type"></code>constant</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">CInt64</span> <span class="keyword">of</span> <code class="type">int64 * <a href="Cil.html#TYPEikind">ikind</a> * string option</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Integer constant. Give the ikind (see ISO9899 6.1.3.2) and the 
 textual representation, if available. (This allows us to print a 
 constant as, for example, 0xF instead of 15.) Use <a href="Cil.html#VALinteger"><code class="code">Cil.integer</code></a> or 
 <a href="Cil.html#VALkinteger"><code class="code">Cil.kinteger</code></a> to create these. Watch out for integers that cannot be 
 represented on 64 bits. OCAML does not give Overflow exceptions.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">CStr</span> <span class="keyword">of</span> <code class="type">string</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >String constant. The escape characters inside the string have been 
 already interpreted. This constant has pointer to character type! The 
 only case when you would like a string literal to have an array type 
 is when it is an argument to sizeof. In that case you should use 
 SizeOfStr.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">CWStr</span> <span class="keyword">of</span> <code class="type">int64 list</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Wide character string constant. Note that the local interpretation
 of such a literal depends on <a href="Cil.html#VALwcharType"><code class="code">Cil.wcharType</code></a> and <a href="Cil.html#VALwcharKind"><code class="code">Cil.wcharKind</code></a>.
 Such a constant has type pointer to <a href="Cil.html#VALwcharType"><code class="code">Cil.wcharType</code></a>. The
 escape characters in the string have not been "interpreted" in 
 the sense that L"A\xabcd" remains "A\xabcd" rather than being
 represented as the wide character list with two elements: 65 and
 43981. That "interpretation" depends on the underlying wide
 character type.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">CChr</span> <span class="keyword">of</span> <code class="type">char</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Character constant.  This has type int, so use charConstToInt
 to read the value in case sign-extension is needed.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">CReal</span> <span class="keyword">of</span> <code class="type">float * <a href="Cil.html#TYPEfkind">fkind</a> * string option</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Floating point constant. Give the fkind (see ISO 6.4.4.2) and also 
 the textual representation, if available.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">CEnum</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a> * string * <a href="Cil.html#TYPEenuminfo">enuminfo</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >An enumeration constant with the given value, name, from the given 
 enuminfo. This is used only if <a href="Cil.html#VALlowerConstants"><code class="code">Cil.lowerConstants</code></a> is true 
 (default). Use <a href="Cil.html#VALconstFoldVisitor"><code class="code">Cil.constFoldVisitor</code></a> to replace these with integer 
 constants.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Literal constants<br>
</div>

<br><code><span id="TYPEunop"><span class="keyword">type</span> <code class="type"></code>unop</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Neg</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Unary minus</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">BNot</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Bitwise complement (~)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">LNot</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Logical Not (!)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Unary operators<br>
</div>

<br><code><span id="TYPEbinop"><span class="keyword">type</span> <code class="type"></code>binop</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PlusA</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >arithmetic +</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PlusPI</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >pointer + integer</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">IndexPI</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >pointer + integer but only when 
 it arises from an expression 
 <code class="code">e[i]</code> when <code class="code">e</code> is a pointer and 
 not an array. This is semantically 
 the same as PlusPI but CCured uses 
 this as a hint that the integer is 
 probably positive.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">MinusA</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >arithmetic -</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">MinusPI</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >pointer - integer</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">MinusPP</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >pointer - pointer</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Mult</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Div</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >/</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Mod</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >%</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Shiftlt</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >shift left</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Shiftrt</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >shift right</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Lt</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >&lt;  (arithmetic comparison)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Gt</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >&gt;  (arithmetic comparison)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Le</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >&lt;= (arithmetic comparison)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Ge</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >&gt;  (arithmetic comparison)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Eq</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >== (arithmetic comparison)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Ne</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >!= (arithmetic comparison)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">BAnd</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >bitwise and</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">BXor</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >exclusive-or</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">BOr</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >inclusive-or</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">LAnd</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >logical and. Unlike other 
 expressions this one does not 
 always evaluate both operands. If 
 you want to use these, you must 
 set <a href="Cil.html#VALuseLogicalOperators"><code class="code">Cil.useLogicalOperators</code></a>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">LOr</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >logical or. Unlike other 
 expressions this one does not 
 always evaluate both operands.  If 
 you want to use these, you must 
 set <a href="Cil.html#VALuseLogicalOperators"><code class="code">Cil.useLogicalOperators</code></a>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Binary operations<br>
</div>

<br>
<b>Lvalues.</b> Lvalues are the sublanguage of expressions that can appear at the left of an assignment or as operand to the address-of operator. 
In C the syntax for lvalues is not always a good indication of the meaning 
of the lvalue. For example the C value
<pre> 
a[0][1][2]
</pre>
 might involve 1, 2 or 3 memory reads when used in an expression context,
depending on the declared type of the variable <code class="code">a</code>. If <code class="code">a</code> has type <code class="code">int
[4][4][4]</code> then we have one memory read from somewhere inside the area 
that stores the array <code class="code">a</code>. On the other hand if <code class="code">a</code> has type <code class="code">int ***</code> then
the expression really means <code class="code">* ( * ( * (a + 0) + 1) + 2)</code>, in which case it is
clear that it involves three separate memory operations. 
<p>

An lvalue denotes the contents of a range of memory addresses. This range 
is denoted as a host object along with an offset within the object. The 
host object can be of two kinds: a local or global variable, or an object 
whose address is in a pointer expression. We distinguish the two cases so 
that we can tell quickly whether we are accessing some component of a 
variable directly or we are accessing a memory location through a pointer.
To make it easy to 
tell what an lvalue means CIL represents lvalues as a host object and an
offset (see <a href="Cil.html#TYPElval"><code class="code">Cil.lval</code></a>). The host object (represented as
<a href="Cil.html#TYPElhost"><code class="code">Cil.lhost</code></a>) can be a local or global variable or can be the object
pointed-to by a pointer expression. The offset (represented as
<a href="Cil.html#TYPEoffset"><code class="code">Cil.offset</code></a>) is a sequence of field or array index designators.
<p>

 Both the typing rules and the meaning of an lvalue is very precisely
specified in CIL. 
<p>

 The following are a few useful function for operating on lvalues:<ul>
<li><a href="Cil.html#VALmkMem"><code class="code">Cil.mkMem</code></a> - makes an lvalue of <code class="code">Mem</code> kind. Use this to ensure
that certain equivalent forms of lvalues are canonized. 
For example, <code class="code">*&amp;x = x</code>. </li>
<li><a href="Cil.html#VALtypeOfLval"><code class="code">Cil.typeOfLval</code></a> - the type of an lvalue</li>
<li><a href="Cil.html#VALtypeOffset"><code class="code">Cil.typeOffset</code></a> - the type of an offset, given the type of the
host. </li>
<li><a href="Cil.html#VALaddOffset"><code class="code">Cil.addOffset</code></a> and <a href="Cil.html#VALaddOffsetLval"><code class="code">Cil.addOffsetLval</code></a> - extend sequences
of offsets.</li>
<li><a href="Cil.html#VALremoveOffset"><code class="code">Cil.removeOffset</code></a> and <a href="Cil.html#VALremoveOffsetLval"><code class="code">Cil.removeOffsetLval</code></a> - shrink sequences
of offsets.</li>
</ul>

The following equivalences hold <pre>
Mem(AddrOf(Mem a, aoff)), off   = Mem a, aoff + off 
Mem(AddrOf(Var v, aoff)), off   = Var v, aoff + off 
AddrOf (Mem a, NoOffset)        = a                 
</pre><br>
<pre><span id="TYPElval"><span class="keyword">type</span> <code class="type"></code>lval</span> = <code class="type"><a href="Cil.html#TYPElhost">lhost</a> * <a href="Cil.html#TYPEoffset">offset</a></code> </pre>
<div class="info">
An lvalue<br>
</div>

<br><code><span id="TYPElhost"><span class="keyword">type</span> <code class="type"></code>lhost</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Var</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEvarinfo">varinfo</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The host is a variable.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Mem</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The host is an object of type <code class="code">T</code> when the expression has pointer 
 <code class="code">TPtr(T)</code>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
The host part of an <a href="Cil.html#TYPElval"><code class="code">Cil.lval</code></a>.<br>
</div>

<br><code><span id="TYPEoffset"><span class="keyword">type</span> <code class="type"></code>offset</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">NoOffset</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >No offset. Can be applied to any lvalue and does 
 not change either the starting address or the type. 
 This is used when the lval consists of just a host 
 or as a terminator in a list of other kinds of 
 offsets.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Field</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEfieldinfo">fieldinfo</a> * <a href="Cil.html#TYPEoffset">offset</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A field offset. Can be applied only to an lvalue 
 that denotes a structure or a union that contains 
 the mentioned field. This advances the offset to the 
 beginning of the mentioned field and changes the 
 type to the type of the mentioned field.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Index</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a> * <a href="Cil.html#TYPEoffset">offset</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >An array index offset. Can be applied only to an 
 lvalue that denotes an array. This advances the 
 starting address of the lval to the beginning of the 
 mentioned array element and changes the denoted type 
 to be the type of the array element</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
The offset part of an <a href="Cil.html#TYPElval"><code class="code">Cil.lval</code></a>. Each offset can be applied to certain 
 kinds of lvalues and its effect is that it advances the starting address 
 of the lvalue and changes the denoted type, essentially focusing to some 
 smaller lvalue that is contained in the original one.<br>
</div>

<br>
<b>Initializers.</b> A special kind of expressions are those that can appear 
 as initializers for global variables (initialization of local variables is 
 turned into assignments). The initializers are represented as type 
 <a href="Cil.html#TYPEinit"><code class="code">Cil.init</code></a>. You can create initializers with <a href="Cil.html#VALmakeZeroInit"><code class="code">Cil.makeZeroInit</code></a> and you 
 can conveniently scan compound initializers them with 
 <a href="Cil.html#VALfoldLeftCompound"><code class="code">Cil.foldLeftCompound</code></a>.<br>
<br><code><span id="TYPEinit"><span class="keyword">type</span> <code class="type"></code>init</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">SingleInit</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A single initializer</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">CompoundInit</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a> * (<a href="Cil.html#TYPEoffset">offset</a> * <a href="Cil.html#TYPEinit">init</a>) list</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Used only for initializers of structures, unions and arrays. The 
 offsets are all of the form <code class="code">Field(f, NoOffset)</code> or <code class="code">Index(i, 
 NoOffset)</code> and specify the field or the index being initialized. For 
 structures all fields must have an initializer (except the unnamed 
 bitfields), in the proper order. This is necessary since the offsets 
 are not printed. For unions there must be exactly one initializer. If 
 the initializer is not for the first field then a field designator is 
 printed, so you better be on GCC since MSVC does not understand this. 
 For arrays, however, we allow you to give only a prefix of the 
 initializers. You can scan an initializer list with 
 <a href="Cil.html#VALfoldLeftCompound"><code class="code">Cil.foldLeftCompound</code></a>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Initializers for global variables.<br>
</div>

<br><code><span id="TYPEinitinfo"><span class="keyword">type</span> <code class="type"></code>initinfo</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>init&nbsp;: <code class="type"><a href="Cil.html#TYPEinit">init</a> option</code>;</code></td>

</tr></table>
}

<div class="info">
We want to be able to update an initializer in a global variable, so we 
 define it as a mutable field<br>
</div>

<br>
<b>Function definitions.</b> 
A function definition is always introduced with a <code class="code">GFun</code> constructor at the
top level. All the information about the function is stored into a
<a href="Cil.html#TYPEfundec"><code class="code">Cil.fundec</code></a>. Some of the information (e.g. its name, type,
storage, attributes) is stored as a <a href="Cil.html#TYPEvarinfo"><code class="code">Cil.varinfo</code></a> that is a field of the
<code class="code">fundec</code>. To refer to the function from the expression language you must use
the <code class="code">varinfo</code>. 
<p>

 The function definition contains, in addition to the body, a list of all the
local variables and separately a list of the formals. Both kind of variables
can be referred to in the body of the function. The formals must also be shared
with the formals that appear in the function type. For that reason, to
manipulate formals you should use the provided functions
<a href="Cil.html#VALmakeFormalVar"><code class="code">Cil.makeFormalVar</code></a> and <a href="Cil.html#VALsetFormals"><code class="code">Cil.setFormals</code></a> and <a href="Cil.html#VALmakeFormalVar"><code class="code">Cil.makeFormalVar</code></a>.<br>
<br><code><span id="TYPEfundec"><span class="keyword">type</span> <code class="type"></code>fundec</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>svar&nbsp;: <code class="type"><a href="Cil.html#TYPEvarinfo">varinfo</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Holds the name and type as a variable, so we can refer to it 
 easily from the program. All references to this function either 
 in a function call or in a prototype must point to the same 
 <code class="code">varinfo</code>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>sformals&nbsp;: <code class="type"><a href="Cil.html#TYPEvarinfo">varinfo</a> list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Formals. These must be in the same order and with the same 
 information as the formal information in the type of the function. 
 Use <a href="Cil.html#VALsetFormals"><code class="code">Cil.setFormals</code></a> or 
 <a href="Cil.html#VALsetFunctionType"><code class="code">Cil.setFunctionType</code></a> or <a href="Cil.html#VALmakeFormalVar"><code class="code">Cil.makeFormalVar</code></a> 
 to set these formals and ensure that they 
 are reflected in the function type. Do not make copies of these 
 because the body refers to them.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>slocals&nbsp;: <code class="type"><a href="Cil.html#TYPEvarinfo">varinfo</a> list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Locals. Does NOT include the sformals. Do not make copies of 
 these because the body refers to them.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>smaxid&nbsp;: <code class="type">int</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Max local id. Starts at 0. Used for 
 creating the names of new temporary 
 variables. Updated by 
 <a href="Cil.html#VALmakeLocalVar"><code class="code">Cil.makeLocalVar</code></a> and 
 <a href="Cil.html#VALmakeTempVar"><code class="code">Cil.makeTempVar</code></a>. You can also use 
 <a href="Cil.html#VALsetMaxId"><code class="code">Cil.setMaxId</code></a> to set it after you 
 have added the formals and locals.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>sbody&nbsp;: <code class="type"><a href="Cil.html#TYPEblock">block</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The function body.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>smaxstmtid&nbsp;: <code class="type">int option</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >max id of a (reachable) statement 
 in this function, if we have 
 computed it. range = 0 ... 
 (smaxstmtid-1). This is computed by 
 <a href="Cil.html#VALcomputeCFGInfo"><code class="code">Cil.computeCFGInfo</code></a>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>sallstmts&nbsp;: <code class="type"><a href="Cil.html#TYPEstmt">stmt</a> list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >After you call <a href="Cil.html#VALcomputeCFGInfo"><code class="code">Cil.computeCFGInfo</code></a> 
 this field is set to contain all 
 statements in the function</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
Function definitions.<br>
</div>

<br><code><span id="TYPEblock"><span class="keyword">type</span> <code class="type"></code>block</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>battrs&nbsp;: <code class="type"><a href="Cil.html#TYPEattributes">attributes</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Attributes for the block</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>bstmts&nbsp;: <code class="type"><a href="Cil.html#TYPEstmt">stmt</a> list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The statements comprising the block</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
A block is a sequence of statements with the control falling through from 
    one element to the next<br>
</div>

<br>
<b>Statements</b>. 
CIL statements are the structural elements that make the CFG. They are 
represented using the type <a href="Cil.html#TYPEstmt"><code class="code">Cil.stmt</code></a>. Every
statement has a (possibly empty) list of labels. The
<a href="Cil.html#TYPEstmtkind"><code class="code">Cil.stmtkind</code></a> field of a statement indicates what kind of statement it 
is.
<p>

 Use <a href="Cil.html#VALmkStmt"><code class="code">Cil.mkStmt</code></a> to make a statement and the fill-in the fields. 
<p>

CIL also comes with support for control-flow graphs. The <code class="code">sid</code> field in
<code class="code">stmt</code> can be used to give unique numbers to statements, and the <code class="code">succs</code>
and <code class="code">preds</code> fields can be used to maintain a list of successors and
predecessors for every statement. The CFG information is not computed by
default. Instead you must explicitly use the functions
<a href="Cil.html#VALprepareCFG"><code class="code">Cil.prepareCFG</code></a> and <a href="Cil.html#VALcomputeCFGInfo"><code class="code">Cil.computeCFGInfo</code></a> to do it.<br>
<br><code><span id="TYPEstmt"><span class="keyword">type</span> <code class="type"></code>stmt</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>labels&nbsp;: <code class="type"><a href="Cil.html#TYPElabel">label</a> list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Whether the statement starts with some labels, case statements or 
 default statements.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>skind&nbsp;: <code class="type"><a href="Cil.html#TYPEstmtkind">stmtkind</a></code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The kind of statement</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>sid&nbsp;: <code class="type">int</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A number (&gt;= 0) that is unique in a function. Filled in only after 
 the CFG is computed.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>succs&nbsp;: <code class="type"><a href="Cil.html#TYPEstmt">stmt</a> list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The successor statements. They can always be computed from the skind 
 and the context in which this statement appears. Filled in only after 
 the CFG is computed.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code><span class="keyword">mutable&nbsp;</span>preds&nbsp;: <code class="type"><a href="Cil.html#TYPEstmt">stmt</a> list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The inverse of the succs function.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
Statements.<br>
</div>

<br><code><span id="TYPElabel"><span class="keyword">type</span> <code class="type"></code>label</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Label</span> <span class="keyword">of</span> <code class="type">string * <a href="Cil.html#TYPElocation">location</a> * bool</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A real label. If the bool is "true", the label is from the 
 input source program. If the bool is "false", the label was 
 created by CIL or some other transformation</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Case</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A case statement. This expression 
 is lowered into a constant if 
 <a href="Cil.html#VALlowerConstants"><code class="code">Cil.lowerConstants</code></a> is set to 
 true.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Default</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A default statement</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Labels<br>
</div>

<br><code><span id="TYPEstmtkind"><span class="keyword">type</span> <code class="type"></code>stmtkind</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Instr</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEinstr">instr</a> list</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A group of instructions that do not contain control flow. Control 
 implicitly falls through.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Return</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a> option * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The return statement. This is a leaf in the CFG.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Goto</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEstmt">stmt</a> ref * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A goto statement. Appears from actual goto's in the code or from 
 goto's that have been inserted during elaboration. The reference 
 points to the statement that is the target of the Goto. This means that 
 you have to update the reference whenever you replace the target 
 statement. The target statement MUST have at least a label.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Break</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A break to the end of the nearest enclosing Loop or Switch</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Continue</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A continue to the start of the nearest enclosing <code class="code">Loop</code></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">If</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a> * <a href="Cil.html#TYPEblock">block</a> * <a href="Cil.html#TYPEblock">block</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A conditional. Two successors, the "then" and the "else" branches. 
 Both branches fall-through to the successor of the If statement.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Switch</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a> * <a href="Cil.html#TYPEblock">block</a> * <a href="Cil.html#TYPEstmt">stmt</a> list * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A switch statement. The statements that implement the cases can be 
 reached through the provided list. For each such target you can find 
 among its labels what cases it implements. The statements that 
 implement the cases are somewhere within the provided <code class="code">block</code>.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Loop</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEblock">block</a> * <a href="Cil.html#TYPElocation">location</a> * <a href="Cil.html#TYPEstmt">stmt</a> option * <a href="Cil.html#TYPEstmt">stmt</a> option</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A <code class="code">while(1)</code> loop. The termination test is implemented in the body of 
 a loop using a <code class="code">Break</code> statement. If prepareCFG has been called,
 the first stmt option will point to the stmt containing the continue
 label for this loop and the second will point to the stmt containing
 the break label for this loop.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Block</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEblock">block</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Just a block of statements. Use it as a way to keep some block 
 attributes local</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TryFinally</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEblock">block</a> * <a href="Cil.html#TYPEblock">block</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TryExcept</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEblock">block</a> * (<a href="Cil.html#TYPEinstr">instr</a> list * <a href="Cil.html#TYPEexp">exp</a>) * <a href="Cil.html#TYPEblock">block</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>

</tr></table>

<div class="info">
The various kinds of control-flow statements statements<br>
</div>

<br>
<b>Instructions</b>. 
 An instruction <a href="Cil.html#TYPEinstr"><code class="code">Cil.instr</code></a> is a statement that has no local
(intraprocedural) control flow. It can be either an assignment,
function call, or an inline assembly instruction.<br>
<br><code><span id="TYPEinstr"><span class="keyword">type</span> <code class="type"></code>instr</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Set</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPElval">lval</a> * <a href="Cil.html#TYPEexp">exp</a> * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >An assignment. The type of the expression is guaranteed to be the same 
 with that of the lvalue</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Call</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPElval">lval</a> option * <a href="Cil.html#TYPEexp">exp</a> * <a href="Cil.html#TYPEexp">exp</a> list * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A function call with the (optional) result placed in an lval. It is 
 possible that the returned type of the function is not identical to 
 that of the lvalue. In that case a cast is printed. The type of the 
 actual arguments are identical to those of the declared formals. The 
 number of arguments is the same as that of the declared formals, except 
 for vararg functions. This construct is also used to encode a call to 
 "__builtin_va_arg". In this case the second argument (which should be a 
 type T) is encoded SizeOf(T)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Asm</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattributes">attributes</a> * string list * (string option * string * <a href="Cil.html#TYPElval">lval</a>) list<br>        * (string option * string * <a href="Cil.html#TYPEexp">exp</a>) list * string list * <a href="Cil.html#TYPElocation">location</a></code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >There are for storing inline assembly. They follow the GCC 
 specification: 
<pre>
  asm [volatile] ("...template..." "..template.."
                  : "c1" (o1), "c2" (o2), ..., "cN" (oN)
                  : "d1" (i1), "d2" (i2), ..., "dM" (iM)
                  : "r1", "r2", ..., "nL" );
</pre>
<p>

where the parts are
<p>
<ul>
<li><code class="code">volatile</code> (optional): when present, the assembler instruction
    cannot be removed, moved, or otherwise optimized</li>
<li>template: a sequence of strings, with %0, %1, %2, etc. in the string to 
    refer to the input and output expressions. I think they're numbered
    consecutively, but the docs don't specify. Each string is printed on 
    a separate line. This is the only part that is present for MSVC inline
    assembly.</li>
<li>"ci" (oi): pairs of constraint-string and output-lval; the 
    constraint specifies that the register used must have some
    property, like being a floating-point register; the constraint
    string for outputs also has "=" to indicate it is written, or
    "+" to indicate it is both read and written; 'oi' is the
    name of a C lvalue (probably a variable name) to be used as
    the output destination</li>
<li>"dj" (ij): pairs of constraint and input expression; the constraint
    is similar to the "ci"s.  the 'ij' is an arbitrary C expression
    to be loaded into the corresponding register</li>
<li>"rk": registers to be regarded as "clobbered" by the instruction;
    "memory" may be specified for arbitrary memory effects</li>
</ul>

an example (from gcc manual):
<pre>
  asm volatile ("movc3 %0,%1,%2"
                : /* no outputs */
                : "g" (from), "g" (to), "g" (count)
                : "r0", "r1", "r2", "r3", "r4", "r5");
</pre>
<p>

 Starting with gcc 3.1, the operands may have names:
<p>

<pre>
  asm volatile ("movc3 %[in0],%1,%2"
                : /* no outputs */
                : [in0] "g" (from), "g" (to), "g" (count)
                : "r0", "r1", "r2", "r3", "r4", "r5");
</pre></td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Instructions.<br>
</div>

<br><code><span id="TYPElocation"><span class="keyword">type</span> <code class="type"></code>location</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>line&nbsp;: <code class="type">int</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The line number. -1 means "do not know"</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>file&nbsp;: <code class="type">string</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The name of the source file</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>byte&nbsp;: <code class="type">int</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The byte position in the source file</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
Describes a location in a source file.<br>
</div>

<br><code><span id="TYPEtypsig"><span class="keyword">type</span> <code class="type"></code>typsig</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TSArray</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtypsig">typsig</a> * int64 option * <a href="Cil.html#TYPEattribute">attribute</a> list</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TSPtr</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtypsig">typsig</a> * <a href="Cil.html#TYPEattribute">attribute</a> list</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TSComp</span> <span class="keyword">of</span> <code class="type">bool * string * <a href="Cil.html#TYPEattribute">attribute</a> list</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TSFun</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtypsig">typsig</a> * <a href="Cil.html#TYPEtypsig">typsig</a> list * bool * <a href="Cil.html#TYPEattribute">attribute</a> list</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TSEnum</span> <span class="keyword">of</span> <code class="type">string * <a href="Cil.html#TYPEattribute">attribute</a> list</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TSBase</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></code></td>

</tr></table>

<div class="info">
Type signatures. Two types are identical iff they have identical 
 signatures. These contain the same information as types but canonicalized. 
 For example, two function types that are identical except for the name of 
 the formal arguments are given the same signature. Also, <code class="code">TNamed</code> 
 constructors are unrolled.<br>
</div>

<br>
<b>Lowering Options</b><br>
<pre><span id="VALlowerConstants"><span class="keyword">val</span> lowerConstants</span> : <code class="type">bool ref</code></pre><div class="info">
Do lower constants (default true)<br>
</div>
<pre><span id="VALinsertImplicitCasts"><span class="keyword">val</span> insertImplicitCasts</span> : <code class="type">bool ref</code></pre><div class="info">
Do insert implicit casts (default true)<br>
</div>
<br><code><span id="TYPEfeatureDescr"><span class="keyword">type</span> <code class="type"></code>featureDescr</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>fd_enabled&nbsp;: <code class="type">bool ref</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >The enable flag. Set to default value</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>fd_name&nbsp;: <code class="type">string</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >This is used to construct an option "--doxxx" and "--dontxxx" that 
 enable and disable the feature</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>fd_description&nbsp;: <code class="type">string</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >A longer name that can be used to document the new options</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>fd_extraopt&nbsp;: <code class="type">(string * Arg.spec * string) list</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Additional command line options.  The description strings should
        usually start with a space for Arg.align to print the --help nicely.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>fd_doit&nbsp;: <code class="type"><a href="Cil.html#TYPEfile">file</a> -> unit</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >This performs the transformation</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>fd_post_check&nbsp;: <code class="type">bool</code>;</code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Whether to perform a CIL consistency checking after this stage, if 
 checking is enabled (--check is passed to cilly). Set this to true if 
 your feature makes any changes for the program.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>
}

<div class="info">
To be able to add/remove features easily, each feature should be package 
 as an interface with the following interface. These features should be<br>
</div>

<pre><span id="VALcompareLoc"><span class="keyword">val</span> compareLoc</span> : <code class="type"><a href="Cil.html#TYPElocation">location</a> -> <a href="Cil.html#TYPElocation">location</a> -> int</code></pre><div class="info">
Comparison function for locations.
* Compares first by filename, then line, then byte<br>
</div>
<br>
<b>Values for manipulating globals</b><br>
<pre><span id="VALemptyFunction"><span class="keyword">val</span> emptyFunction</span> : <code class="type">string -> <a href="Cil.html#TYPEfundec">fundec</a></code></pre><div class="info">
Make an empty function<br>
</div>
<pre><span id="VALsetFormals"><span class="keyword">val</span> setFormals</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> -> <a href="Cil.html#TYPEvarinfo">varinfo</a> list -> unit</code></pre><div class="info">
Update the formals of a <code class="code">fundec</code> and make sure that the function type 
    has the same information. Will copy the name as well into the type.<br>
</div>
<pre><span id="VALsetFunctionType"><span class="keyword">val</span> setFunctionType</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> -> <a href="Cil.html#TYPEtyp">typ</a> -> unit</code></pre><div class="info">
Set the types of arguments and results as given by the function type 
 passed as the second argument. Will not copy the names from the function 
 type to the formals<br>
</div>
<pre><span id="VALsetFunctionTypeMakeFormals"><span class="keyword">val</span> setFunctionTypeMakeFormals</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> -> <a href="Cil.html#TYPEtyp">typ</a> -> unit</code></pre><div class="info">
Set the type of the function and make formal arguments for them<br>
</div>
<pre><span id="VALsetMaxId"><span class="keyword">val</span> setMaxId</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> -> unit</code></pre><div class="info">
Update the smaxid after you have populated with locals and formals 
 (unless you constructed those using <a href="Cil.html#VALmakeLocalVar"><code class="code">Cil.makeLocalVar</code></a> or 
 <a href="Cil.html#VALmakeTempVar"><code class="code">Cil.makeTempVar</code></a>.<br>
</div>
<pre><span id="VALdummyFunDec"><span class="keyword">val</span> dummyFunDec</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a></code></pre><div class="info">
A dummy function declaration handy when you need one as a placeholder. It 
 contains inside a dummy varinfo.<br>
</div>
<pre><span id="VALdummyFile"><span class="keyword">val</span> dummyFile</span> : <code class="type"><a href="Cil.html#TYPEfile">file</a></code></pre><div class="info">
A dummy file<br>
</div>
<pre><span id="VALsaveBinaryFile"><span class="keyword">val</span> saveBinaryFile</span> : <code class="type"><a href="Cil.html#TYPEfile">file</a> -> string -> unit</code></pre><div class="info">
Write a <a href="Cil.html#TYPEfile"><code class="code">Cil.file</code></a> in binary form to the filesystem. The file can be
 read back in later using <a href="Cil.html#VALloadBinaryFile"><code class="code">Cil.loadBinaryFile</code></a>, possibly saving parsing
 time. The second argument is the name of the file that should be
 created.<br>
</div>
<pre><span id="VALsaveBinaryFileChannel"><span class="keyword">val</span> saveBinaryFileChannel</span> : <code class="type"><a href="Cil.html#TYPEfile">file</a> -> out_channel -> unit</code></pre><div class="info">
Write a <a href="Cil.html#TYPEfile"><code class="code">Cil.file</code></a> in binary form to the filesystem. The file can be
 read back in later using <a href="Cil.html#VALloadBinaryFile"><code class="code">Cil.loadBinaryFile</code></a>, possibly saving parsing
 time. Does not close the channel.<br>
</div>
<pre><span id="VALloadBinaryFile"><span class="keyword">val</span> loadBinaryFile</span> : <code class="type">string -> <a href="Cil.html#TYPEfile">file</a></code></pre><div class="info">
Read a <a href="Cil.html#TYPEfile"><code class="code">Cil.file</code></a> in binary form from the filesystem. The first
 argument is the name of a file previously created by
 <a href="Cil.html#VALsaveBinaryFile"><code class="code">Cil.saveBinaryFile</code></a>. Because this also reads some global state,
 this should be called before any other CIL code is parsed or generated.<br>
</div>
<pre><span id="VALgetGlobInit"><span class="keyword">val</span> getGlobInit</span> : <code class="type">?main_name:string -> <a href="Cil.html#TYPEfile">file</a> -> <a href="Cil.html#TYPEfundec">fundec</a></code></pre><div class="info">
Get the global initializer and create one if it does not already exist. 
 When it creates a global initializer it attempts to place a call to it in 
 the main function named by the optional argument (default "main")<br>
</div>
<pre><span id="VALiterGlobals"><span class="keyword">val</span> iterGlobals</span> : <code class="type"><a href="Cil.html#TYPEfile">file</a> -> (<a href="Cil.html#TYPEglobal">global</a> -> unit) -> unit</code></pre><div class="info">
Iterate over all globals, including the global initializer<br>
</div>
<pre><span id="VALfoldGlobals"><span class="keyword">val</span> foldGlobals</span> : <code class="type"><a href="Cil.html#TYPEfile">file</a> -> ('a -> <a href="Cil.html#TYPEglobal">global</a> -> 'a) -> 'a -> 'a</code></pre><div class="info">
Fold over all globals, including the global initializer<br>
</div>
<pre><span id="VALmapGlobals"><span class="keyword">val</span> mapGlobals</span> : <code class="type"><a href="Cil.html#TYPEfile">file</a> -> (<a href="Cil.html#TYPEglobal">global</a> -> <a href="Cil.html#TYPEglobal">global</a>) -> unit</code></pre><div class="info">
Map over all globals, including the global initializer and change things 
    in place<br>
</div>
<pre><span id="VALfindOrCreateFunc"><span class="keyword">val</span> findOrCreateFunc</span> : <code class="type"><a href="Cil.html#TYPEfile">file</a> -> string -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEvarinfo">varinfo</a></code></pre><div class="info">
Find a function or function prototype with the given name in the file.
 If it does not exist, create a prototype with the given type, and return
 the new varinfo.  This is useful when you need to call a libc function
 whose prototype may or may not already exist in the file.
<p>

 Because the new prototype is added to the start of the file, you shouldn't
 refer to any struct or union types in the function type.<br>
</div>
<pre><span id="VALnew_sid"><span class="keyword">val</span> new_sid</span> : <code class="type">unit -> int</code></pre><pre><span id="VALprepareCFG"><span class="keyword">val</span> prepareCFG</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> -> unit</code></pre><div class="info">
Prepare a function for CFG information computation by
 <a href="Cil.html#VALcomputeCFGInfo"><code class="code">Cil.computeCFGInfo</code></a>. This function converts all <code class="code">Break</code>, <code class="code">Switch</code>,
 <code class="code">Default</code> and <code class="code">Continue</code> <a href="Cil.html#TYPEstmtkind"><code class="code">Cil.stmtkind</code></a>s and <a href="Cil.html#TYPElabel"><code class="code">Cil.label</code></a>s into <code class="code">If</code>s
 and <code class="code">Goto</code>s, giving the function body a very CFG-like character. This
 function modifies its argument in place.<br>
</div>
<pre><span id="VALcomputeCFGInfo"><span class="keyword">val</span> computeCFGInfo</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> -> bool -> unit</code></pre><div class="info">
Compute the CFG information for all statements in a fundec and return a 
 list of the statements. The input fundec cannot have <code class="code">Break</code>, <code class="code">Switch</code>, 
 <code class="code">Default</code>, or <code class="code">Continue</code> <a href="Cil.html#TYPEstmtkind"><code class="code">Cil.stmtkind</code></a>s or <a href="Cil.html#TYPElabel"><code class="code">Cil.label</code></a>s. Use
 <a href="Cil.html#VALprepareCFG"><code class="code">Cil.prepareCFG</code></a> to transform them away.  The second argument should
 be <code class="code">true</code> if you wish a global statement number, <code class="code">false</code> if you wish a
 local (per-function) statement numbering. The list of statements is set 
 in the sallstmts field of a fundec. 
<p>

 NOTE: unless you want the simpler control-flow graph provided by
 prepareCFG, or you need the function's smaxstmtid and sallstmt fields
 filled in, we recommend you use <a href="Cfg.html#VALcomputeFileCFG"><code class="code">Cfg.computeFileCFG</code></a> instead of this
 function to compute control-flow information.
 <a href="Cfg.html#VALcomputeFileCFG"><code class="code">Cfg.computeFileCFG</code></a> is newer and will handle switch, break, and
 continue correctly.<br>
</div>
<pre><span id="VALcopyFunction"><span class="keyword">val</span> copyFunction</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> -> string -> <a href="Cil.html#TYPEfundec">fundec</a></code></pre><div class="info">
Create a deep copy of a function. There should be no sharing between the 
 copy and the original function<br>
</div>
<pre><span id="VALpushGlobal"><span class="keyword">val</span> pushGlobal</span> : <code class="type"><a href="Cil.html#TYPEglobal">global</a> -><br>       types:<a href="Cil.html#TYPEglobal">global</a> list ref -><br>       variables:<a href="Cil.html#TYPEglobal">global</a> list ref -> unit</code></pre><div class="info">
CIL keeps the types at the beginning of the file and the variables at the 
 end of the file. This function will take a global and add it to the 
 corresponding stack. Its operation is actually more complicated because if 
 the global declares a type that contains references to variables (e.g. in 
 sizeof in an array length) then it will also add declarations for the 
 variables to the types stack<br>
</div>
<pre><span id="VALinvalidStmt"><span class="keyword">val</span> invalidStmt</span> : <code class="type"><a href="Cil.html#TYPEstmt">stmt</a></code></pre><div class="info">
An empty statement. Used in pretty printing<br>
</div>
<pre><span id="VALbuiltinFunctions"><span class="keyword">val</span> builtinFunctions</span> : <code class="type">(string, <a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEtyp">typ</a> list * bool) Hashtbl.t</code></pre><div class="info">
A list of the built-in functions for the current compiler (GCC or
 MSVC, depending on <code class="code">!msvcMode</code>).  Maps the name to the
 result and argument types, and whether it is vararg.
 Initialized by <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a>
<p>

 This map replaces <code class="code">gccBuiltins</code> and <code class="code">msvcBuiltins</code> in previous
 versions of CIL.<br>
</div>
<pre><span id="VALbuiltinLoc"><span class="keyword">val</span> builtinLoc</span> : <code class="type"><a href="Cil.html#TYPElocation">location</a></code></pre><div class="info">
This is used as the location of the prototypes of builtin functions.<br>
</div>
<br>
<b>Values for manipulating initializers</b><br>
<pre><span id="VALmakeZeroInit"><span class="keyword">val</span> makeZeroInit</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEinit">init</a></code></pre><div class="info">
Make a initializer for zero-ing a data type<br>
</div>
<pre><span id="VALfoldLeftCompound"><span class="keyword">val</span> foldLeftCompound</span> : <code class="type">implicit:bool -><br>       doinit:(<a href="Cil.html#TYPEoffset">offset</a> -> <a href="Cil.html#TYPEinit">init</a> -> <a href="Cil.html#TYPEtyp">typ</a> -> 'a -> 'a) -><br>       ct:<a href="Cil.html#TYPEtyp">typ</a> -> initl:(<a href="Cil.html#TYPEoffset">offset</a> * <a href="Cil.html#TYPEinit">init</a>) list -> acc:'a -> 'a</code></pre><div class="info">
Fold over the list of initializers in a Compound (not also the nested 
 ones). <code class="code">doinit</code> is called on every present initializer, even if it is of 
 compound type. The parameters of <code class="code">doinit</code> are: the offset in the compound 
 (this is <code class="code">Field(f,NoOffset)</code> or <code class="code">Index(i,NoOffset)</code>), the initializer 
 value, expected type of the initializer value, accumulator. In the case of 
 arrays there might be missing zero-initializers at the end of the list. 
 These are scanned only if <code class="code">implicit</code> is true. This is much like 
 <code class="code">List.fold_left</code> except we also pass the type of the initializer. 
<p>

 This is a good way to use it to scan even nested initializers :
<pre>
  let rec myInit (lv: lval) (i: init) (acc: 'a) : 'a = 
      match i with 
        SingleInit e -&gt; ... do something with lv and e and acc ...
      | CompoundInit (ct, initl) -&gt;  
         foldLeftCompound ~implicit:false
             ~doinit:(fun off' i' t' acc -&gt; 
                        myInit (addOffsetLval lv off') i' acc)
             ~ct:ct
             ~initl:initl
             ~acc:acc</pre><br>
</div>
<br>
<b>Values for manipulating types</b><br>
<pre><span id="VALvoidType"><span class="keyword">val</span> voidType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
void<br>
</div>
<pre><span id="VALisVoidType"><span class="keyword">val</span> isVoidType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> bool</code></pre><div class="info">
is the given type "void"?<br>
</div>
<pre><span id="VALisVoidPtrType"><span class="keyword">val</span> isVoidPtrType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> bool</code></pre><div class="info">
is the given type "void *"?<br>
</div>
<pre><span id="VALintType"><span class="keyword">val</span> intType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
int<br>
</div>
<pre><span id="VALuintType"><span class="keyword">val</span> uintType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
unsigned int<br>
</div>
<pre><span id="VALlongType"><span class="keyword">val</span> longType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
long<br>
</div>
<pre><span id="VALulongType"><span class="keyword">val</span> ulongType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
unsigned long<br>
</div>
<pre><span id="VALcharType"><span class="keyword">val</span> charType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
char<br>
</div>
<pre><span id="VALcharPtrType"><span class="keyword">val</span> charPtrType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
char *<br>
</div>
<pre><span id="VALwcharKind"><span class="keyword">val</span> wcharKind</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> ref</code></pre><div class="info">
wchar_t (depends on architecture) and is set when you call 
 <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a>.<br>
</div>
<pre><span id="VALwcharType"><span class="keyword">val</span> wcharType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> ref</code></pre><pre><span id="VALcharConstPtrType"><span class="keyword">val</span> charConstPtrType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
char const *<br>
</div>
<pre><span id="VALvoidPtrType"><span class="keyword">val</span> voidPtrType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
void *<br>
</div>
<pre><span id="VALintPtrType"><span class="keyword">val</span> intPtrType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
int *<br>
</div>
<pre><span id="VALuintPtrType"><span class="keyword">val</span> uintPtrType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
unsigned int *<br>
</div>
<pre><span id="VALdoubleType"><span class="keyword">val</span> doubleType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
double<br>
</div>
<pre><span id="VALupointType"><span class="keyword">val</span> upointType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> ref</code></pre><div class="info">
An unsigned integer type that fits pointers. Depends on <a href="Cil.html#VALmsvcMode"><code class="code">Cil.msvcMode</code></a> 
  and is set when you call <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a>.<br>
</div>
<pre><span id="VALtypeOfSizeOf"><span class="keyword">val</span> typeOfSizeOf</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> ref</code></pre><div class="info">
An unsigned integer type that is the type of sizeof. Depends on 
 <a href="Cil.html#VALmsvcMode"><code class="code">Cil.msvcMode</code></a> and is set when you call <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a>.<br>
</div>
<pre><span id="VALkindOfSizeOf"><span class="keyword">val</span> kindOfSizeOf</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> ref</code></pre><div class="info">
The integer kind of <a href="Cil.html#VALtypeOfSizeOf"><code class="code">Cil.typeOfSizeOf</code></a>. 
  Set when you call <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a>.<br>
</div>
<pre><span id="VALisSigned"><span class="keyword">val</span> isSigned</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> bool</code></pre><div class="info">
Returns true if and only if the given integer type is signed.<br>
</div>
<pre><span id="VALmkCompInfo"><span class="keyword">val</span> mkCompInfo</span> : <code class="type">bool -><br>       string -><br>       (<a href="Cil.html#TYPEcompinfo">compinfo</a> -><br>        (string * <a href="Cil.html#TYPEtyp">typ</a> * int option * <a href="Cil.html#TYPEattributes">attributes</a> * <a href="Cil.html#TYPElocation">location</a>) list) -><br>       <a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Cil.html#TYPEcompinfo">compinfo</a></code></pre><div class="info">
Creates a a (potentially recursive) composite type. The arguments are: 
 (1) a boolean indicating whether it is a struct or a union, (2) the name 
 (always non-empty), (3) a function that when given a representation of the 
 structure type constructs the type of the fields recursive type (the first 
 argument is only useful when some fields need to refer to the type of the 
 structure itself), and (4) a list of attributes to be associated with the 
 composite type. The resulting compinfo has the field "cdefined" only if 
 the list of fields is non-empty.<br>
</div>
<pre><span id="VALcopyCompInfo"><span class="keyword">val</span> copyCompInfo</span> : <code class="type"><a href="Cil.html#TYPEcompinfo">compinfo</a> -> string -> <a href="Cil.html#TYPEcompinfo">compinfo</a></code></pre><div class="info">
Makes a shallow copy of a <a href="Cil.html#TYPEcompinfo"><code class="code">Cil.compinfo</code></a> changing the name and the key.<br>
</div>
<pre><span id="VALmissingFieldName"><span class="keyword">val</span> missingFieldName</span> : <code class="type">string</code></pre><div class="info">
This is a constant used as the name of an unnamed bitfield. These fields
    do not participate in initialization and their name is not printed.<br>
</div>
<pre><span id="VALcompFullName"><span class="keyword">val</span> compFullName</span> : <code class="type"><a href="Cil.html#TYPEcompinfo">compinfo</a> -> string</code></pre><div class="info">
Get the full name of a comp<br>
</div>
<pre><span id="VALisCompleteType"><span class="keyword">val</span> isCompleteType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> bool</code></pre><div class="info">
Returns true if this is a complete type. 
   This means that sizeof(t) makes sense. 
   Incomplete types are not yet defined 
   structures and empty arrays.<br>
</div>
<pre><span id="VALunrollType"><span class="keyword">val</span> unrollType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
Unroll a type until it exposes a non 
 <code class="code">TNamed</code>. Will collect all attributes appearing in <code class="code">TNamed</code>!!!<br>
</div>
<pre><span id="VALunrollTypeDeep"><span class="keyword">val</span> unrollTypeDeep</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
Unroll all the TNamed in a type (even under type constructors such as 
 <code class="code">TPtr</code>, <code class="code">TFun</code> or <code class="code">TArray</code>. Does not unroll the types of fields in <code class="code">TComp</code> 
 types. Will collect all attributes<br>
</div>
<pre><span id="VALseparateStorageModifiers"><span class="keyword">val</span> separateStorageModifiers</span> : <code class="type"><a href="Cil.html#TYPEattribute">attribute</a> list -> <a href="Cil.html#TYPEattribute">attribute</a> list * <a href="Cil.html#TYPEattribute">attribute</a> list</code></pre><div class="info">
Separate out the storage-modifier name attributes<br>
</div>
<pre><span id="VALisIntegralType"><span class="keyword">val</span> isIntegralType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> bool</code></pre><div class="info">
True if the argument is an integral type (i.e. integer or enum)<br>
</div>
<pre><span id="VALisArithmeticType"><span class="keyword">val</span> isArithmeticType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> bool</code></pre><div class="info">
True if the argument is an arithmetic type (i.e. integer, enum or 
    floating point<br>
</div>
<pre><span id="VALisPointerType"><span class="keyword">val</span> isPointerType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> bool</code></pre><div class="info">
True if the argument is a pointer type<br>
</div>
<pre><span id="VALisScalarType"><span class="keyword">val</span> isScalarType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> bool</code></pre><div class="info">
True if the argument is a scalar type<br>
</div>
<pre><span id="VALisFunctionType"><span class="keyword">val</span> isFunctionType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> bool</code></pre><div class="info">
True if the argument is a function type<br>
</div>
<pre><span id="VALargsToList"><span class="keyword">val</span> argsToList</span> : <code class="type">(string * <a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEattributes">attributes</a>) list option -><br>       (string * <a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEattributes">attributes</a>) list</code></pre><div class="info">
Obtain the argument list ([] if None)<br>
</div>
<pre><span id="VALisArrayType"><span class="keyword">val</span> isArrayType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> bool</code></pre><div class="info">
True if the argument is an array type<br>
</div>
<pre><span id="EXCEPTIONLenOfArray"><span class="keyword">exception</span> LenOfArray</span></pre>
<div class="info">
Raised when <a href="Cil.html#VALlenOfArray"><code class="code">Cil.lenOfArray</code></a> fails either because the length is <code class="code">None</code> 
 or because it is a non-constant expression<br>
</div>
<pre><span id="VALlenOfArray"><span class="keyword">val</span> lenOfArray</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a> option -> int</code></pre><div class="info">
Call to compute the array length as present in the array type, to an 
 integer. Raises <a href="Cil.html#EXCEPTIONLenOfArray"><code class="code">Cil.LenOfArray</code></a> if not able to compute the length, such 
 as when there is no length or the length is not a constant.<br>
</div>
<pre><span id="VALgetCompField"><span class="keyword">val</span> getCompField</span> : <code class="type"><a href="Cil.html#TYPEcompinfo">compinfo</a> -> string -> <a href="Cil.html#TYPEfieldinfo">fieldinfo</a></code></pre><div class="info">
Return a named fieldinfo in compinfo, or raise Not_found<br>
</div>
<br><code><span id="TYPEexistsAction"><span class="keyword">type</span> <code class="type"></code>existsAction</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ExistsTrue</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >We have found it</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ExistsFalse</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Stop processing this branch</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ExistsMaybe</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >This node is not what we are 
 looking for but maybe its 
 successors are</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
A datatype to be used in conjunction with <code class="code">existsType</code><br>
</div>

<pre><span id="VALexistsType"><span class="keyword">val</span> existsType</span> : <code class="type">(<a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEexistsAction">existsAction</a>) -> <a href="Cil.html#TYPEtyp">typ</a> -> bool</code></pre><div class="info">
Scans a type by applying the function on all elements. 
    When the function returns ExistsTrue, the scan stops with
    true. When the function returns ExistsFalse then the current branch is not
    scanned anymore. Care is taken to 
    apply the function only once on each composite type, thus avoiding 
    circularity. When the function returns ExistsMaybe then the types that 
    construct the current type are scanned (e.g. the base type for TPtr and 
    TArray, the type of fields for a TComp, etc).<br>
</div>
<pre><span id="VALsplitFunctionType"><span class="keyword">val</span> splitFunctionType</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -><br>       <a href="Cil.html#TYPEtyp">typ</a> * (string * <a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEattributes">attributes</a>) list option * bool *<br>       <a href="Cil.html#TYPEattributes">attributes</a></code></pre><div class="info">
Given a function type split it into return type, 
 arguments, is_vararg and attributes. An error is raised if the type is not 
 a function type
<p>
Same as <a href="Cil.html#VALsplitFunctionType"><code class="code">Cil.splitFunctionType</code></a> but takes a varinfo. Prints a nicer 
 error message if the varinfo is not for a function<br>
</div>
<pre><span id="VALsplitFunctionTypeVI"><span class="keyword">val</span> splitFunctionTypeVI</span> : <code class="type"><a href="Cil.html#TYPEvarinfo">varinfo</a> -><br>       <a href="Cil.html#TYPEtyp">typ</a> * (string * <a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEattributes">attributes</a>) list option * bool *<br>       <a href="Cil.html#TYPEattributes">attributes</a></code></pre><br>
<b>Type signatures</b><br>
<br>
Type signatures. Two types are identical iff they have identical 
 signatures. These contain the same information as types but canonicalized. 
 For example, two function types that are identical except for the name of 
 the formal arguments are given the same signature. Also, <code class="code">TNamed</code> 
 constructors are unrolled.<br>
<pre><span id="VALd_typsig"><span class="keyword">val</span> d_typsig</span> : <code class="type">unit -> <a href="Cil.html#TYPEtypsig">typsig</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print a type signature<br>
</div>
<pre><span id="VALtypeSig"><span class="keyword">val</span> typeSig</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEtypsig">typsig</a></code></pre><div class="info">
Compute a type signature<br>
</div>
<pre><span id="VALtypeSigWithAttrs"><span class="keyword">val</span> typeSigWithAttrs</span> : <code class="type">?ignoreSign:bool -><br>       (<a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Cil.html#TYPEattributes">attributes</a>) -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEtypsig">typsig</a></code></pre><div class="info">
Like <a href="Cil.html#VALtypeSig"><code class="code">Cil.typeSig</code></a> but customize the incorporation of attributes.
    Use ~ignoreSign:true to convert all signed integer types to unsigned,
    so that signed and unsigned will compare the same.<br>
</div>
<pre><span id="VALsetTypeSigAttrs"><span class="keyword">val</span> setTypeSigAttrs</span> : <code class="type"><a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Cil.html#TYPEtypsig">typsig</a> -> <a href="Cil.html#TYPEtypsig">typsig</a></code></pre><div class="info">
Replace the attributes of a signature (only at top level)<br>
</div>
<pre><span id="VALtypeSigAttrs"><span class="keyword">val</span> typeSigAttrs</span> : <code class="type"><a href="Cil.html#TYPEtypsig">typsig</a> -> <a href="Cil.html#TYPEattributes">attributes</a></code></pre><div class="info">
Get the top-level attributes of a signature<br>
</div>
<br>
<b>Lvalues</b><br>
<pre><span id="VALmakeVarinfo"><span class="keyword">val</span> makeVarinfo</span> : <code class="type">bool -> string -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEvarinfo">varinfo</a></code></pre><div class="info">
Make a varinfo. Use this (rarely) to make a raw varinfo. Use other 
 functions to make locals (<a href="Cil.html#VALmakeLocalVar"><code class="code">Cil.makeLocalVar</code></a> or <a href="Cil.html#VALmakeFormalVar"><code class="code">Cil.makeFormalVar</code></a> or 
 <a href="Cil.html#VALmakeTempVar"><code class="code">Cil.makeTempVar</code></a>) and globals (<a href="Cil.html#VALmakeGlobalVar"><code class="code">Cil.makeGlobalVar</code></a>). Note that this 
 function will assign a new identifier. The first argument specifies 
 whether the varinfo is for a global.<br>
</div>
<pre><span id="VALmakeFormalVar"><span class="keyword">val</span> makeFormalVar</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> -> ?where:string -> string -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEvarinfo">varinfo</a></code></pre><div class="info">
Make a formal variable for a function. Insert it in both the sformals 
    and the type of the function. You can optionally specify where to insert 
    this one. If where = "^" then it is inserted first. If where = "$" then 
    it is inserted last. Otherwise where must be the name of a formal after 
    which to insert this. By default it is inserted at the end.<br>
</div>
<pre><span id="VALmakeLocalVar"><span class="keyword">val</span> makeLocalVar</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> -> ?insert:bool -> string -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEvarinfo">varinfo</a></code></pre><div class="info">
Make a local variable and add it to a function's slocals (only if insert = 
    true, which is the default). Make sure you know what you are doing if you 
    set insert=false.<br>
</div>
<pre><span id="VALmakeTempVar"><span class="keyword">val</span> makeTempVar</span> : <code class="type"><a href="Cil.html#TYPEfundec">fundec</a> -><br>       ?insert:bool -><br>       ?name:string -><br>       ?descr:<a href="Pretty.html#TYPEdoc">Pretty.doc</a> -> ?descrpure:bool -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEvarinfo">varinfo</a></code></pre><div class="info">
Make a temporary variable and add it to a function's slocals. CIL will
    ensure that the name of the new variable is unique in this function, and
    will generate this name by appending a number to the specified string
    ("__cil_tmp" by default).
<p>

    The variable will be added to the function's slocals unless you explicitly
    set insert=false.  (Make sure you know what you are doing if you set
    insert=false.)
<p>

    Optionally, you can give the variable a description of its contents
    that will be printed by descriptiveCilPrinter.<br>
</div>
<pre><span id="VALmakeGlobalVar"><span class="keyword">val</span> makeGlobalVar</span> : <code class="type">string -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEvarinfo">varinfo</a></code></pre><div class="info">
Make a global variable. Your responsibility to make sure that the name 
    is unique<br>
</div>
<pre><span id="VALcopyVarinfo"><span class="keyword">val</span> copyVarinfo</span> : <code class="type"><a href="Cil.html#TYPEvarinfo">varinfo</a> -> string -> <a href="Cil.html#TYPEvarinfo">varinfo</a></code></pre><div class="info">
Make a shallow copy of a <code class="code">varinfo</code> and assign a new identifier<br>
</div>
<pre><span id="VALnewVID"><span class="keyword">val</span> newVID</span> : <code class="type">unit -> int</code></pre><div class="info">
Generate a new variable ID. This will be different than any variable ID 
 that is generated by <a href="Cil.html#VALmakeLocalVar"><code class="code">Cil.makeLocalVar</code></a> and friends<br>
</div>
<pre><span id="VALaddOffsetLval"><span class="keyword">val</span> addOffsetLval</span> : <code class="type"><a href="Cil.html#TYPEoffset">offset</a> -> <a href="Cil.html#TYPElval">lval</a> -> <a href="Cil.html#TYPElval">lval</a></code></pre><div class="info">
Add an offset at the end of an lvalue. Make sure the type of the lvalue 
 and the offset are compatible.<br>
</div>
<pre><span id="VALaddOffset"><span class="keyword">val</span> addOffset</span> : <code class="type"><a href="Cil.html#TYPEoffset">offset</a> -> <a href="Cil.html#TYPEoffset">offset</a> -> <a href="Cil.html#TYPEoffset">offset</a></code></pre><div class="info">
<code class="code">addOffset o1 o2</code> adds <code class="code">o1</code> to the end of <code class="code">o2</code>.<br>
</div>
<pre><span id="VALremoveOffsetLval"><span class="keyword">val</span> removeOffsetLval</span> : <code class="type"><a href="Cil.html#TYPElval">lval</a> -> <a href="Cil.html#TYPElval">lval</a> * <a href="Cil.html#TYPEoffset">offset</a></code></pre><div class="info">
Remove ONE offset from the end of an lvalue. Returns the lvalue with the 
 trimmed offset and the final offset. If the final offset is <code class="code">NoOffset</code> 
 then the original <code class="code">lval</code> did not have an offset.<br>
</div>
<pre><span id="VALremoveOffset"><span class="keyword">val</span> removeOffset</span> : <code class="type"><a href="Cil.html#TYPEoffset">offset</a> -> <a href="Cil.html#TYPEoffset">offset</a> * <a href="Cil.html#TYPEoffset">offset</a></code></pre><div class="info">
Remove ONE offset from the end of an offset sequence. Returns the 
 trimmed offset and the final offset. If the final offset is <code class="code">NoOffset</code> 
 then the original <code class="code">lval</code> did not have an offset.<br>
</div>
<pre><span id="VALtypeOfLval"><span class="keyword">val</span> typeOfLval</span> : <code class="type"><a href="Cil.html#TYPElval">lval</a> -> <a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
Compute the type of an lvalue<br>
</div>
<pre><span id="VALtypeOffset"><span class="keyword">val</span> typeOffset</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEoffset">offset</a> -> <a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
Compute the type of an offset from a base type<br>
</div>
<br>
<b>Values for manipulating expressions</b><br>
<pre><span id="VALzero"><span class="keyword">val</span> zero</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
0<br>
</div>
<pre><span id="VALone"><span class="keyword">val</span> one</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
1<br>
</div>
<pre><span id="VALmone"><span class="keyword">val</span> mone</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
-1<br>
</div>
<pre><span id="VALkintegerCilint"><span class="keyword">val</span> kintegerCilint</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> Cilint.cilint -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Construct an integer of a given kind, from a cilint. If needed it
 will truncate the integer to be within the representable range for
 the given kind.<br>
</div>
<pre><span id="VALkinteger64"><span class="keyword">val</span> kinteger64</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> int64 -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Construct an integer of a given kind, using OCaml's int64 type. If needed 
 it will truncate the integer to be within the representable range for the 
 given kind.<br>
</div>
<pre><span id="VALkinteger"><span class="keyword">val</span> kinteger</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> int -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Construct an integer of a given kind. Converts the integer to int64 and 
 then uses kinteger64. This might truncate the value if you use a kind 
 that cannot represent the given integer. This can only happen for one of 
 the Char or Short kinds<br>
</div>
<pre><span id="VALinteger"><span class="keyword">val</span> integer</span> : <code class="type">int -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Construct an integer of kind IInt. On targets where C's 'int' is 16-bits,
    the integer may get truncated.<br>
</div>
<pre><span id="VALgetInteger"><span class="keyword">val</span> getInteger</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a> -> Cilint.cilint option</code></pre><div class="info">
If the given expression is an integer constant or a CastE'd
    integer constant, return that constant's value. 
    Otherwise return None.<br>
</div>
<pre><span id="VALi64_to_int"><span class="keyword">val</span> i64_to_int</span> : <code class="type">int64 -> int</code></pre><div class="info">
Convert a 64-bit int to an OCaml int, or raise an exception if that
    can't be done.<br>
</div>
<pre><span id="VALcilint_to_int"><span class="keyword">val</span> cilint_to_int</span> : <code class="type">Cilint.cilint -> int</code></pre><div class="info">
Convert a cilint int to an OCaml int, or raise an exception if that
    can't be done.<br>
</div>
<pre><span id="VALisConstant"><span class="keyword">val</span> isConstant</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a> -> bool</code></pre><div class="info">
True if the expression is a compile-time constant<br>
</div>
<pre><span id="VALisConstantOffset"><span class="keyword">val</span> isConstantOffset</span> : <code class="type"><a href="Cil.html#TYPEoffset">offset</a> -> bool</code></pre><div class="info">
True if the given offset contains only field nanmes or constant indices.<br>
</div>
<pre><span id="VALisZero"><span class="keyword">val</span> isZero</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a> -> bool</code></pre><div class="info">
True if the given expression is a (possibly cast'ed) integer or character 
    constant with value zero<br>
</div>
<pre><span id="VALcharConstToInt"><span class="keyword">val</span> charConstToInt</span> : <code class="type">char -> <a href="Cil.html#TYPEconstant">constant</a></code></pre><div class="info">
Given the character c in a (CChr c), sign-extend it to 32 bits.
  (This is the official way of interpreting character constants, according to
  ISO C 6.4.4.4.10, which says that character constants are chars cast to ints)
  Returns CInt64(sign-extened c, IInt, None)<br>
</div>
<pre><span id="VALconstFold"><span class="keyword">val</span> constFold</span> : <code class="type">bool -> <a href="Cil.html#TYPEexp">exp</a> -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Do constant folding on an expression. If the first argument is true then 
    will also compute compiler-dependent expressions such as sizeof.
    See also <a href="Cil.html#VALconstFoldVisitor"><code class="code">Cil.constFoldVisitor</code></a>, which will run constFold on all
    expressions in a given AST node.<br>
</div>
<pre><span id="VALconstFoldBinOp"><span class="keyword">val</span> constFoldBinOp</span> : <code class="type">bool -> <a href="Cil.html#TYPEbinop">binop</a> -> <a href="Cil.html#TYPEexp">exp</a> -> <a href="Cil.html#TYPEexp">exp</a> -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Do constant folding on a binary operation. The bulk of the work done by 
    <code class="code">constFold</code> is done here. If the first argument is true then 
    will also compute compiler-dependent expressions such as sizeof<br>
</div>
<pre><span id="VALincrem"><span class="keyword">val</span> increm</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a> -> int -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Increment an expression. Can be arithmetic or pointer type<br>
</div>
<pre><span id="VALvar"><span class="keyword">val</span> var</span> : <code class="type"><a href="Cil.html#TYPEvarinfo">varinfo</a> -> <a href="Cil.html#TYPElval">lval</a></code></pre><div class="info">
Makes an lvalue out of a given variable<br>
</div>
<pre><span id="VALmkAddrOf"><span class="keyword">val</span> mkAddrOf</span> : <code class="type"><a href="Cil.html#TYPElval">lval</a> -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Make an AddrOf. Given an lvalue of type T will give back an expression of 
    type ptr(T). It optimizes somewhat expressions like "&amp; v" and "&amp; v<code class="code">0</code>"<br>
</div>
<pre><span id="VALmkAddrOrStartOf"><span class="keyword">val</span> mkAddrOrStartOf</span> : <code class="type"><a href="Cil.html#TYPElval">lval</a> -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Like mkAddrOf except if the type of lval is an array then it uses 
    StartOf. This is the right operation for getting a pointer to the start 
    of the storage denoted by lval.<br>
</div>
<pre><span id="VALmkMem"><span class="keyword">val</span> mkMem</span> : <code class="type">addr:<a href="Cil.html#TYPEexp">exp</a> -> off:<a href="Cil.html#TYPEoffset">offset</a> -> <a href="Cil.html#TYPElval">lval</a></code></pre><div class="info">
Make a Mem, while optimizing AddrOf. The type of the addr must be 
    TPtr(t) and the type of the resulting lval is t. Note that in CIL the 
    implicit conversion between an array and the pointer to the first 
    element does not apply. You must do the conversion yourself using 
    StartOf<br>
</div>
<pre><span id="VALmkString"><span class="keyword">val</span> mkString</span> : <code class="type">string -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Make an expression that is a string constant (of pointer type)<br>
</div>
<pre><span id="VALmkCastT"><span class="keyword">val</span> mkCastT</span> : <code class="type">e:<a href="Cil.html#TYPEexp">exp</a> -> oldt:<a href="Cil.html#TYPEtyp">typ</a> -> newt:<a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Construct a cast when having the old type of the expression. If the new 
 type is the same as the old type, then no cast is added.<br>
</div>
<pre><span id="VALmkCast"><span class="keyword">val</span> mkCast</span> : <code class="type">e:<a href="Cil.html#TYPEexp">exp</a> -> newt:<a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Like <a href="Cil.html#VALmkCastT"><code class="code">Cil.mkCastT</code></a> but uses typeOf to get <code class="code">oldt</code><br>
</div>
<pre><span id="VALstripCasts"><span class="keyword">val</span> stripCasts</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a> -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Removes casts from this expression, but ignores casts within
  other expression constructs.  So we delete the (A) and (B) casts from 
  "(A)(B)(x + (C)y)", but leave the (C) cast.<br>
</div>
<pre><span id="VALtypeOf"><span class="keyword">val</span> typeOf</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a> -> <a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
Compute the type of an expression<br>
</div>
<pre><span id="VALparseInt"><span class="keyword">val</span> parseInt</span> : <code class="type">string -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Convert a string representing a C integer literal to an expression. 
 Handles the prefixes 0x and 0 and the suffixes L, U, UL, LL, ULL<br>
</div>
<br>
<b>Values for manipulating statements</b><br>
<pre><span id="VALmkStmt"><span class="keyword">val</span> mkStmt</span> : <code class="type"><a href="Cil.html#TYPEstmtkind">stmtkind</a> -> <a href="Cil.html#TYPEstmt">stmt</a></code></pre><div class="info">
Construct a statement, given its kind. Initialize the <code class="code">sid</code> field to -1,
    and <code class="code">labels</code>, <code class="code">succs</code> and <code class="code">preds</code> to the empty list<br>
</div>
<pre><span id="VALmkBlock"><span class="keyword">val</span> mkBlock</span> : <code class="type"><a href="Cil.html#TYPEstmt">stmt</a> list -> <a href="Cil.html#TYPEblock">block</a></code></pre><div class="info">
Construct a block with no attributes, given a list of statements<br>
</div>
<pre><span id="VALmkStmtOneInstr"><span class="keyword">val</span> mkStmtOneInstr</span> : <code class="type"><a href="Cil.html#TYPEinstr">instr</a> -> <a href="Cil.html#TYPEstmt">stmt</a></code></pre><div class="info">
Construct a statement consisting of just one instruction<br>
</div>
<pre><span id="VALcompactStmts"><span class="keyword">val</span> compactStmts</span> : <code class="type"><a href="Cil.html#TYPEstmt">stmt</a> list -> <a href="Cil.html#TYPEstmt">stmt</a> list</code></pre><div class="info">
Try to compress statements so as to get maximal basic blocks.
 use this instead of List.@ because you get fewer basic blocks<br>
</div>
<pre><span id="VALmkEmptyStmt"><span class="keyword">val</span> mkEmptyStmt</span> : <code class="type">unit -> <a href="Cil.html#TYPEstmt">stmt</a></code></pre><div class="info">
Returns an empty statement (of kind <code class="code">Instr</code>)<br>
</div>
<pre><span id="VALdummyInstr"><span class="keyword">val</span> dummyInstr</span> : <code class="type"><a href="Cil.html#TYPEinstr">instr</a></code></pre><div class="info">
A instr to serve as a placeholder<br>
</div>
<pre><span id="VALdummyStmt"><span class="keyword">val</span> dummyStmt</span> : <code class="type"><a href="Cil.html#TYPEstmt">stmt</a></code></pre><div class="info">
A statement consisting of just <code class="code">dummyInstr</code><br>
</div>
<pre><span id="VALmkWhile"><span class="keyword">val</span> mkWhile</span> : <code class="type">guard:<a href="Cil.html#TYPEexp">exp</a> -> body:<a href="Cil.html#TYPEstmt">stmt</a> list -> <a href="Cil.html#TYPEstmt">stmt</a> list</code></pre><div class="info">
Make a while loop. Can contain Break or Continue<br>
</div>
<pre><span id="VALmkForIncr"><span class="keyword">val</span> mkForIncr</span> : <code class="type">iter:<a href="Cil.html#TYPEvarinfo">varinfo</a> -><br>       first:<a href="Cil.html#TYPEexp">exp</a> -><br>       stopat:<a href="Cil.html#TYPEexp">exp</a> -> incr:<a href="Cil.html#TYPEexp">exp</a> -> body:<a href="Cil.html#TYPEstmt">stmt</a> list -> <a href="Cil.html#TYPEstmt">stmt</a> list</code></pre><div class="info">
Make a for loop for(i=start; i&lt;past; i += incr) { ... }. The body 
    can contain Break but not Continue. Can be used with i a pointer 
    or an integer. Start and done must have the same type but incr 
    must be an integer<br>
</div>
<pre><span id="VALmkFor"><span class="keyword">val</span> mkFor</span> : <code class="type">start:<a href="Cil.html#TYPEstmt">stmt</a> list -><br>       guard:<a href="Cil.html#TYPEexp">exp</a> -> next:<a href="Cil.html#TYPEstmt">stmt</a> list -> body:<a href="Cil.html#TYPEstmt">stmt</a> list -> <a href="Cil.html#TYPEstmt">stmt</a> list</code></pre><div class="info">
Make a for loop for(start; guard; next) { ... }. The body can 
    contain Break but not Continue !!!<br>
</div>
<br>
<b>Values for manipulating attributes</b><br>
<br><code><span id="TYPEattributeClass"><span class="keyword">type</span> <code class="type"></code>attributeClass</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AttrName</span> <span class="keyword">of</span> <code class="type">bool</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Attribute of a name. If argument is true and we are on MSVC then 
            the attribute is printed using __declspec as part of the storage 
            specifier</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AttrFunType</span> <span class="keyword">of</span> <code class="type">bool</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Attribute of a function type. If argument is true and we are on 
            MSVC then the attribute is printed just before the function name</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">AttrType</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Attribute of a type</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Various classes of attributes<br>
</div>

<pre><span id="VALattributeHash"><span class="keyword">val</span> attributeHash</span> : <code class="type">(string, <a href="Cil.html#TYPEattributeClass">attributeClass</a>) Hashtbl.t</code></pre><div class="info">
This table contains the mapping of predefined attributes to classes. 
    Extend this table with more attributes as you need. This table is used to 
    determine how to associate attributes with names or types<br>
</div>
<pre><span id="VALpartitionAttributes"><span class="keyword">val</span> partitionAttributes</span> : <code class="type">default:<a href="Cil.html#TYPEattributeClass">attributeClass</a> -><br>       <a href="Cil.html#TYPEattributes">attributes</a> -><br>       <a href="Cil.html#TYPEattribute">attribute</a> list * <a href="Cil.html#TYPEattribute">attribute</a> list * <a href="Cil.html#TYPEattribute">attribute</a> list</code></pre><div class="info">
Partition the attributes into classes:name attributes, function type, 
    and type attributes<br>
</div>
<pre><span id="VALaddAttribute"><span class="keyword">val</span> addAttribute</span> : <code class="type"><a href="Cil.html#TYPEattribute">attribute</a> -> <a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Cil.html#TYPEattributes">attributes</a></code></pre><div class="info">
Add an attribute. Maintains the attributes in sorted order of the second 
    argument<br>
</div>
<pre><span id="VALaddAttributes"><span class="keyword">val</span> addAttributes</span> : <code class="type"><a href="Cil.html#TYPEattribute">attribute</a> list -> <a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Cil.html#TYPEattributes">attributes</a></code></pre><div class="info">
Add a list of attributes. Maintains the attributes in sorted order. The 
    second argument must be sorted, but not necessarily the first<br>
</div>
<pre><span id="VALdropAttribute"><span class="keyword">val</span> dropAttribute</span> : <code class="type">string -> <a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Cil.html#TYPEattributes">attributes</a></code></pre><div class="info">
Remove all attributes with the given name. Maintains the attributes in 
    sorted order.<br>
</div>
<pre><span id="VALdropAttributes"><span class="keyword">val</span> dropAttributes</span> : <code class="type">string list -> <a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Cil.html#TYPEattributes">attributes</a></code></pre><div class="info">
Remove all attributes with names appearing in the string list.
  Maintains the attributes in sorted order<br>
</div>
<pre><span id="VALfilterAttributes"><span class="keyword">val</span> filterAttributes</span> : <code class="type">string -> <a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Cil.html#TYPEattributes">attributes</a></code></pre><div class="info">
Retains attributes with the given name<br>
</div>
<pre><span id="VALhasAttribute"><span class="keyword">val</span> hasAttribute</span> : <code class="type">string -> <a href="Cil.html#TYPEattributes">attributes</a> -> bool</code></pre><div class="info">
True if the named attribute appears in the attribute list. The list of
    attributes must be sorted.<br>
</div>
<pre><span id="VALtypeAttrs"><span class="keyword">val</span> typeAttrs</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEattribute">attribute</a> list</code></pre><div class="info">
Returns all the attributes contained in a type. This requires a traversal 
    of the type structure, in case of composite, enumeration and named types<br>
</div>
<pre><span id="VALsetTypeAttrs"><span class="keyword">val</span> setTypeAttrs</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Cil.html#TYPEtyp">typ</a></code></pre><pre><span id="VALtypeAddAttributes"><span class="keyword">val</span> typeAddAttributes</span> : <code class="type"><a href="Cil.html#TYPEattribute">attribute</a> list -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
Add some attributes to a type<br>
</div>
<pre><span id="VALtypeRemoveAttributes"><span class="keyword">val</span> typeRemoveAttributes</span> : <code class="type">string list -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
Remove all attributes with the given names from a type. Note that this
    does not remove attributes from typedef and tag definitions, just from 
    their uses<br>
</div>
<pre><span id="VALexpToAttrParam"><span class="keyword">val</span> expToAttrParam</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a> -> <a href="Cil.html#TYPEattrparam">attrparam</a></code></pre><div class="info">
Convert an expression into an attrparam, if possible. Otherwise raise
    NotAnAttrParam with the offending subexpression<br>
</div>
<pre><span id="EXCEPTIONNotAnAttrParam"><span class="keyword">exception</span> NotAnAttrParam</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a></code></pre>
<br>
<b>The visitor</b><br>
<br><code><span id="TYPEvisitAction"><span class="keyword">type</span> <code class="type">'a</code> visitAction</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">SkipChildren</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Do not visit the children. Return 
                                            the node as it is.</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">DoChildren</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Continue with the children of this 
                                            node. Rebuild the node on return 
                                            if any of the children changes 
                                            (use == test)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ChangeTo</span> <span class="keyword">of</span> <code class="type">'a</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Replace the expression with the 
                                            given one</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ChangeDoChildrenPost</span> <span class="keyword">of</span> <code class="type">'a * ('a -> 'a)</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >First consider that the entire 
                                           exp is replaced by the first 
                                           parameter. Then continue with 
                                           the children. On return rebuild 
                                           the node if any of the children 
                                           has changed and then apply the 
                                           function on the node</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Different visiting actions. 'a will be instantiated with <code class="code">exp</code>, <code class="code">instr</code>,
    etc.<br>
</div>

<pre><span id="TYPEcilVisitor"><span class="keyword">class type</span> <a href="Cil.cilVisitor-c.html">cilVisitor</a></span> = <code class="code">object</code> <a href="Cil.cilVisitor-c.html">..</a> <code class="code">end</code></pre><div class="info">
A visitor interface for traversing CIL trees.
</div>
<pre><span name="TYPEnopCilVisitor"><span class="keyword">class</span> <a href="Cil.nopCilVisitor-c.html">nopCilVisitor</a></span> : <code class="type"></code><code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a></code></pre><div class="info">
Default Visitor.
</div>
<pre><span id="VALvisitCilFile"><span class="keyword">val</span> visitCilFile</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEfile">file</a> -> unit</code></pre><div class="info">
Visit a file. This will will re-cons all globals TWICE (so that it is 
 tail-recursive). Use <a href="Cil.html#VALvisitCilFileSameGlobals"><code class="code">Cil.visitCilFileSameGlobals</code></a> if your visitor will 
 not change the list of globals.<br>
</div>
<pre><span id="VALvisitCilFileSameGlobals"><span class="keyword">val</span> visitCilFileSameGlobals</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEfile">file</a> -> unit</code></pre><div class="info">
A visitor for the whole file that does not change the globals (but maybe
 changes things inside the globals). Use this function instead of
 <a href="Cil.html#VALvisitCilFile"><code class="code">Cil.visitCilFile</code></a> whenever appropriate because it is more efficient for
 long files.<br>
</div>
<pre><span id="VALvisitCilGlobal"><span class="keyword">val</span> visitCilGlobal</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEglobal">global</a> -> <a href="Cil.html#TYPEglobal">global</a> list</code></pre><div class="info">
Visit a global<br>
</div>
<pre><span id="VALvisitCilFunction"><span class="keyword">val</span> visitCilFunction</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEfundec">fundec</a> -> <a href="Cil.html#TYPEfundec">fundec</a></code></pre><div class="info">
Visit a function definition<br>
</div>
<pre><span id="VALvisitCilExpr"><span class="keyword">val</span> visitCilExpr</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEexp">exp</a> -> <a href="Cil.html#TYPEexp">exp</a></code></pre><pre><span id="VALvisitCilLval"><span class="keyword">val</span> visitCilLval</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPElval">lval</a> -> <a href="Cil.html#TYPElval">lval</a></code></pre><div class="info">
Visit an lvalue<br>
</div>
<pre><span id="VALvisitCilOffset"><span class="keyword">val</span> visitCilOffset</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEoffset">offset</a> -> <a href="Cil.html#TYPEoffset">offset</a></code></pre><div class="info">
Visit an lvalue or recursive offset<br>
</div>
<pre><span id="VALvisitCilInitOffset"><span class="keyword">val</span> visitCilInitOffset</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEoffset">offset</a> -> <a href="Cil.html#TYPEoffset">offset</a></code></pre><div class="info">
Visit an initializer offset<br>
</div>
<pre><span id="VALvisitCilInstr"><span class="keyword">val</span> visitCilInstr</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEinstr">instr</a> -> <a href="Cil.html#TYPEinstr">instr</a> list</code></pre><div class="info">
Visit an instruction<br>
</div>
<pre><span id="VALvisitCilStmt"><span class="keyword">val</span> visitCilStmt</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEstmt">stmt</a> -> <a href="Cil.html#TYPEstmt">stmt</a></code></pre><div class="info">
Visit a statement<br>
</div>
<pre><span id="VALvisitCilBlock"><span class="keyword">val</span> visitCilBlock</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEblock">block</a> -> <a href="Cil.html#TYPEblock">block</a></code></pre><div class="info">
Visit a block<br>
</div>
<pre><span id="VALvisitCilType"><span class="keyword">val</span> visitCilType</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEtyp">typ</a></code></pre><div class="info">
Visit a type<br>
</div>
<pre><span id="VALvisitCilVarDecl"><span class="keyword">val</span> visitCilVarDecl</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEvarinfo">varinfo</a> -> <a href="Cil.html#TYPEvarinfo">varinfo</a></code></pre><div class="info">
Visit a variable declaration<br>
</div>
<pre><span id="VALvisitCilInit"><span class="keyword">val</span> visitCilInit</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEvarinfo">varinfo</a> -> <a href="Cil.html#TYPEoffset">offset</a> -> <a href="Cil.html#TYPEinit">init</a> -> <a href="Cil.html#TYPEinit">init</a></code></pre><div class="info">
Visit an initializer, pass also the global to which this belongs and the 
 offset.<br>
</div>
<pre><span id="VALvisitCilAttributes"><span class="keyword">val</span> visitCilAttributes</span> : <code class="type"><a href="Cil.cilVisitor-c.html">cilVisitor</a> -> <a href="Cil.html#TYPEattribute">attribute</a> list -> <a href="Cil.html#TYPEattribute">attribute</a> list</code></pre><div class="info">
Visit a list of attributes<br>
</div>
<br>
<b>Utility functions</b><br>
<pre><span id="VALmsvcMode"><span class="keyword">val</span> msvcMode</span> : <code class="type">bool ref</code></pre><div class="info">
Whether the pretty printer should print output for the MS VC compiler.
   Default is GCC. After you set this function you should call <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a>.<br>
</div>
<pre><span id="VALuseLogicalOperators"><span class="keyword">val</span> useLogicalOperators</span> : <code class="type">bool ref</code></pre><div class="info">
Whether to use the logical operands LAnd and LOr. By default, do not use 
 them because they are unlike other expressions and do not evaluate both of 
 their operands<br>
</div>
<pre><span id="VALoldstyleExternInline"><span class="keyword">val</span> oldstyleExternInline</span> : <code class="type">bool ref</code></pre><div class="info">
Set this to true to get old-style handling of gcc's extern inline C extension:
   old-style: the extern inline definition is used until the actual definition is
     seen (as long as optimization is enabled)
   new-style: the extern inline definition is used only if there is no actual
     definition (as long as optimization is enabled)
   Note that CIL assumes that optimization is always enabled ;-)<br>
</div>
<pre><span id="VALconstFoldVisitor"><span class="keyword">val</span> constFoldVisitor</span> : <code class="type">bool -> <a href="Cil.cilVisitor-c.html">cilVisitor</a></code></pre><div class="info">
A visitor that does constant folding. Pass as argument whether you want 
 machine specific simplifications to be done, or not.<br>
</div>
<br><code><span id="TYPElineDirectiveStyle"><span class="keyword">type</span> <code class="type"></code>lineDirectiveStyle</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">LineComment</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Before every element, print the line 
 number in comments. This is ignored by 
 processing tools (thus errors are reproted 
 in the CIL output), but useful for 
 visual inspection</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">LineCommentSparse</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Like LineComment but only print a line 
 directive for a new source line</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">LinePreprocessorInput</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Use # nnn directives (in gcc mode)</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">LinePreprocessorOutput</span></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >Use #line directives</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr></table>

<div class="info">
Styles of printing line directives<br>
</div>

<pre><span id="VALlineDirectiveStyle"><span class="keyword">val</span> lineDirectiveStyle</span> : <code class="type"><a href="Cil.html#TYPElineDirectiveStyle">lineDirectiveStyle</a> option ref</code></pre><div class="info">
How to print line directives<br>
</div>
<pre><span id="VALprint_CIL_Input"><span class="keyword">val</span> print_CIL_Input</span> : <code class="type">bool ref</code></pre><div class="info">
Whether we print something that will only be used as input to our own 
 parser. In that case we are a bit more liberal in what we print<br>
</div>
<pre><span id="VALprintCilAsIs"><span class="keyword">val</span> printCilAsIs</span> : <code class="type">bool ref</code></pre><div class="info">
Whether to print the CIL as they are, without trying to be smart and 
 print nicer code. Normally this is false, in which case the pretty 
 printer will turn the while(1) loops of CIL into nicer loops, will not 
 print empty "else" blocks, etc. There is one case howewer in which if you 
 turn this on you will get code that does not compile: if you use varargs 
 the __builtin_va_arg function will be printed in its internal form.<br>
</div>
<pre><span id="VALlineLength"><span class="keyword">val</span> lineLength</span> : <code class="type">int ref</code></pre><div class="info">
The length used when wrapping output lines.  Setting this variable to
 a large integer will prevent wrapping and make #line directives more
 accurate.<br>
</div>
<pre><span id="VALforgcc"><span class="keyword">val</span> forgcc</span> : <code class="type">string -> string</code></pre><div class="info">
Return the string 's' if we're printing output for gcc, suppres
  it if we're printing for CIL to parse back in.  the purpose is to
  hide things from gcc that it complains about, but still be able
  to do lossless transformations when CIL is the consumer<br>
</div>
<br>
<b>Debugging support</b><br>
<pre><span id="VALcurrentLoc"><span class="keyword">val</span> currentLoc</span> : <code class="type"><a href="Cil.html#TYPElocation">location</a> ref</code></pre><div class="info">
A reference to the current location. If you are careful to set this to 
 the current location then you can use some built-in logging functions that 
 will print the location.<br>
</div>
<pre><span id="VALcurrentGlobal"><span class="keyword">val</span> currentGlobal</span> : <code class="type"><a href="Cil.html#TYPEglobal">global</a> ref</code></pre><div class="info">
A reference to the current global being visited<br>
</div>
<br>
CIL has a fairly easy to use mechanism for printing error messages. This 
 mechanism is built on top of the pretty-printer mechanism (see 
 <a href="Pretty.html#TYPEdoc"><code class="code">Pretty.doc</code></a>) and the error-message modules (see <a href="Errormsg.html#VALerror"><code class="code">Errormsg.error</code></a>). 
<p>

 Here is a typical example for printing a log message: <pre>
ignore (Errormsg.log "Expression %a is not positive (at %s:%i)\n"
                        d_exp e loc.file loc.line)
</pre>
<p>

 and here is an example of how you print a fatal error message that stop the 
 execution: <pre>
Errormsg.s (Errormsg.bug "Why am I here?")
</pre>
<p>

 Notice that you can use C format strings with some extension. The most 
useful extension is "%a" that means to consumer the next two argument from 
the argument list and to apply the first to <code class="code">unit</code> and then to the second 
and to print the resulting <a href="Pretty.html#TYPEdoc"><code class="code">Pretty.doc</code></a>. For each major type in CIL there is 
a corresponding function that pretty-prints an element of that type:<br>
<pre><span id="VALd_loc"><span class="keyword">val</span> d_loc</span> : <code class="type">unit -> <a href="Cil.html#TYPElocation">location</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a location<br>
</div>
<pre><span id="VALd_thisloc"><span class="keyword">val</span> d_thisloc</span> : <code class="type">unit -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print the <a href="Cil.html#VALcurrentLoc"><code class="code">Cil.currentLoc</code></a><br>
</div>
<pre><span id="VALd_ikind"><span class="keyword">val</span> d_ikind</span> : <code class="type">unit -> <a href="Cil.html#TYPEikind">ikind</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print an integer of a given kind<br>
</div>
<pre><span id="VALd_fkind"><span class="keyword">val</span> d_fkind</span> : <code class="type">unit -> <a href="Cil.html#TYPEfkind">fkind</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a floating-point kind<br>
</div>
<pre><span id="VALd_storage"><span class="keyword">val</span> d_storage</span> : <code class="type">unit -> <a href="Cil.html#TYPEstorage">storage</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print storage-class information<br>
</div>
<pre><span id="VALd_const"><span class="keyword">val</span> d_const</span> : <code class="type">unit -> <a href="Cil.html#TYPEconstant">constant</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a constant<br>
</div>
<pre><span id="VALderefStarLevel"><span class="keyword">val</span> derefStarLevel</span> : <code class="type">int</code></pre><pre><span id="VALindexLevel"><span class="keyword">val</span> indexLevel</span> : <code class="type">int</code></pre><pre><span id="VALarrowLevel"><span class="keyword">val</span> arrowLevel</span> : <code class="type">int</code></pre><pre><span id="VALaddrOfLevel"><span class="keyword">val</span> addrOfLevel</span> : <code class="type">int</code></pre><pre><span id="VALadditiveLevel"><span class="keyword">val</span> additiveLevel</span> : <code class="type">int</code></pre><pre><span id="VALcomparativeLevel"><span class="keyword">val</span> comparativeLevel</span> : <code class="type">int</code></pre><pre><span id="VALbitwiseLevel"><span class="keyword">val</span> bitwiseLevel</span> : <code class="type">int</code></pre><pre><span id="VALgetParenthLevel"><span class="keyword">val</span> getParenthLevel</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a> -> int</code></pre><div class="info">
Parentheses level. An expression "a op b" is printed parenthesized if its 
 parentheses level is &gt;= that that of its context. Identifiers have the 
 lowest level and weakly binding operators (e.g. |) have the largest level. 
 The correctness criterion is that a smaller level MUST correspond to a 
 stronger precedence!<br>
</div>
<pre><span id="TYPEcilPrinter"><span class="keyword">class type</span> <a href="Cil.cilPrinter-c.html">cilPrinter</a></span> = <code class="code">object</code> <a href="Cil.cilPrinter-c.html">..</a> <code class="code">end</code></pre><div class="info">
A printer interface for CIL trees.
</div>
<pre><span name="TYPEdefaultCilPrinterClass"><span class="keyword">class</span> <a href="Cil.defaultCilPrinterClass-c.html">defaultCilPrinterClass</a></span> : <code class="type"></code><code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a></code></pre><pre><span id="VALdefaultCilPrinter"><span class="keyword">val</span> defaultCilPrinter</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a></code></pre><pre><span name="TYPEplainCilPrinterClass"><span class="keyword">class</span> <a href="Cil.plainCilPrinterClass-c.html">plainCilPrinterClass</a></span> : <code class="type"></code><code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a></code></pre><div class="info">
These are pretty-printers that will show you more details on the internal 
 CIL representation, without trying hard to make it look like C
</div>
<pre><span id="VALplainCilPrinter"><span class="keyword">val</span> plainCilPrinter</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a></code></pre><pre><span id="TYPEdescriptiveCilPrinter"><span class="keyword">class type</span> <a href="Cil.descriptiveCilPrinter-c.html">descriptiveCilPrinter</a></span> = <code class="code">object</code> <a href="Cil.descriptiveCilPrinter-c.html">..</a> <code class="code">end</code></pre><pre><span name="TYPEdescriptiveCilPrinterClass"><span class="keyword">class</span> <a href="Cil.descriptiveCilPrinterClass-c.html">descriptiveCilPrinterClass</a></span> : <code class="type">bool -> </code><code class="type"><a href="Cil.descriptiveCilPrinter-c.html">descriptiveCilPrinter</a></code></pre><div class="info">
Like defaultCilPrinterClass, but instead of temporary variable
      names it prints the description that was provided when the temp was
      created.
</div>
<pre><span id="VALdescriptiveCilPrinter"><span class="keyword">val</span> descriptiveCilPrinter</span> : <code class="type"><a href="Cil.descriptiveCilPrinter-c.html">descriptiveCilPrinter</a></code></pre><pre><span id="VALprinterForMaincil"><span class="keyword">val</span> printerForMaincil</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> ref</code></pre><div class="info">
zra: This is the pretty printer that Maincil will use.
   by default it is set to defaultCilPrinter<br>
</div>
<pre><span id="VALprintType"><span class="keyword">val</span> printType</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> unit -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print a type given a pretty printer<br>
</div>
<pre><span id="VALprintExp"><span class="keyword">val</span> printExp</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> unit -> <a href="Cil.html#TYPEexp">exp</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print an expression given a pretty printer<br>
</div>
<pre><span id="VALprintLval"><span class="keyword">val</span> printLval</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> unit -> <a href="Cil.html#TYPElval">lval</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print an lvalue given a pretty printer<br>
</div>
<pre><span id="VALprintGlobal"><span class="keyword">val</span> printGlobal</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> unit -> <a href="Cil.html#TYPEglobal">global</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print a global given a pretty printer<br>
</div>
<pre><span id="VALprintAttr"><span class="keyword">val</span> printAttr</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> unit -> <a href="Cil.html#TYPEattribute">attribute</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print an attribute given a pretty printer<br>
</div>
<pre><span id="VALprintAttrs"><span class="keyword">val</span> printAttrs</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> unit -> <a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print a set of attributes given a pretty printer<br>
</div>
<pre><span id="VALprintInstr"><span class="keyword">val</span> printInstr</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> unit -> <a href="Cil.html#TYPEinstr">instr</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print an instruction given a pretty printer<br>
</div>
<pre><span id="VALprintStmt"><span class="keyword">val</span> printStmt</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> unit -> <a href="Cil.html#TYPEstmt">stmt</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print a statement given a pretty printer. This can take very long 
 (or even overflow the stack) for huge statements. Use <a href="Cil.html#VALdumpStmt"><code class="code">Cil.dumpStmt</code></a> 
 instead.<br>
</div>
<pre><span id="VALprintBlock"><span class="keyword">val</span> printBlock</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> unit -> <a href="Cil.html#TYPEblock">block</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print a block given a pretty printer. This can take very long 
 (or even overflow the stack) for huge block. Use <a href="Cil.html#VALdumpBlock"><code class="code">Cil.dumpBlock</code></a> 
 instead.<br>
</div>
<pre><span id="VALdumpStmt"><span class="keyword">val</span> dumpStmt</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> out_channel -> int -> <a href="Cil.html#TYPEstmt">stmt</a> -> unit</code></pre><div class="info">
Dump a statement to a file using a given indentation. Use this instead of 
 <a href="Cil.html#VALprintStmt"><code class="code">Cil.printStmt</code></a> whenever possible.<br>
</div>
<pre><span id="VALdumpBlock"><span class="keyword">val</span> dumpBlock</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> out_channel -> int -> <a href="Cil.html#TYPEblock">block</a> -> unit</code></pre><div class="info">
Dump a block to a file using a given indentation. Use this instead of 
 <a href="Cil.html#VALprintBlock"><code class="code">Cil.printBlock</code></a> whenever possible.<br>
</div>
<pre><span id="VALprintInit"><span class="keyword">val</span> printInit</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> unit -> <a href="Cil.html#TYPEinit">init</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Print an initializer given a pretty printer. This can take very long 
 (or even overflow the stack) for huge initializers. Use <a href="Cil.html#VALdumpInit"><code class="code">Cil.dumpInit</code></a> 
 instead.<br>
</div>
<pre><span id="VALdumpInit"><span class="keyword">val</span> dumpInit</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> out_channel -> int -> <a href="Cil.html#TYPEinit">init</a> -> unit</code></pre><div class="info">
Dump an initializer to a file using a given indentation. Use this instead of 
 <a href="Cil.html#VALprintInit"><code class="code">Cil.printInit</code></a> whenever possible.<br>
</div>
<pre><span id="VALd_type"><span class="keyword">val</span> d_type</span> : <code class="type">unit -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a type using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a><br>
</div>
<pre><span id="VALd_exp"><span class="keyword">val</span> d_exp</span> : <code class="type">unit -> <a href="Cil.html#TYPEexp">exp</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print an expression using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a><br>
</div>
<pre><span id="VALd_lval"><span class="keyword">val</span> d_lval</span> : <code class="type">unit -> <a href="Cil.html#TYPElval">lval</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print an lvalue using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a><br>
</div>
<pre><span id="VALd_offset"><span class="keyword">val</span> d_offset</span> : <code class="type"><a href="Pretty.html#TYPEdoc">Pretty.doc</a> -> unit -> <a href="Cil.html#TYPEoffset">offset</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print an offset using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a>, given the pretty 
 printing for the base.<br>
</div>
<pre><span id="VALd_init"><span class="keyword">val</span> d_init</span> : <code class="type">unit -> <a href="Cil.html#TYPEinit">init</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print an initializer using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a>.  This can be 
 extremely slow (or even overflow the stack) for huge initializers. Use 
 <a href="Cil.html#VALdumpInit"><code class="code">Cil.dumpInit</code></a> instead.<br>
</div>
<pre><span id="VALd_binop"><span class="keyword">val</span> d_binop</span> : <code class="type">unit -> <a href="Cil.html#TYPEbinop">binop</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a binary operator<br>
</div>
<pre><span id="VALd_unop"><span class="keyword">val</span> d_unop</span> : <code class="type">unit -> <a href="Cil.html#TYPEunop">unop</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a unary operator<br>
</div>
<pre><span id="VALd_attr"><span class="keyword">val</span> d_attr</span> : <code class="type">unit -> <a href="Cil.html#TYPEattribute">attribute</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print an attribute using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a><br>
</div>
<pre><span id="VALd_attrparam"><span class="keyword">val</span> d_attrparam</span> : <code class="type">unit -> <a href="Cil.html#TYPEattrparam">attrparam</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print an argument of an attribute using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a><br>
</div>
<pre><span id="VALd_attrlist"><span class="keyword">val</span> d_attrlist</span> : <code class="type">unit -> <a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a list of attributes using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a><br>
</div>
<pre><span id="VALd_instr"><span class="keyword">val</span> d_instr</span> : <code class="type">unit -> <a href="Cil.html#TYPEinstr">instr</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print an instruction using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a><br>
</div>
<pre><span id="VALd_label"><span class="keyword">val</span> d_label</span> : <code class="type">unit -> <a href="Cil.html#TYPElabel">label</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a label using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a><br>
</div>
<pre><span id="VALd_stmt"><span class="keyword">val</span> d_stmt</span> : <code class="type">unit -> <a href="Cil.html#TYPEstmt">stmt</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a statement using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a>. This can be 
 extremely slow (or even overflow the stack) for huge statements. Use 
 <a href="Cil.html#VALdumpStmt"><code class="code">Cil.dumpStmt</code></a> instead.<br>
</div>
<pre><span id="VALd_block"><span class="keyword">val</span> d_block</span> : <code class="type">unit -> <a href="Cil.html#TYPEblock">block</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a block using <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a>. This can be 
 extremely slow (or even overflow the stack) for huge blocks. Use 
 <a href="Cil.html#VALdumpBlock"><code class="code">Cil.dumpBlock</code></a> instead.<br>
</div>
<pre><span id="VALd_global"><span class="keyword">val</span> d_global</span> : <code class="type">unit -> <a href="Cil.html#TYPEglobal">global</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print the internal representation of a global using 
 <a href="Cil.html#VALdefaultCilPrinter"><code class="code">Cil.defaultCilPrinter</code></a>. This can be extremely slow (or even overflow the 
 stack) for huge globals (such as arrays with lots of initializers). Use 
 <a href="Cil.html#VALdumpGlobal"><code class="code">Cil.dumpGlobal</code></a> instead.<br>
</div>
<pre><span id="VALdn_exp"><span class="keyword">val</span> dn_exp</span> : <code class="type">unit -> <a href="Cil.html#TYPEexp">exp</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Versions of the above pretty printers, that don't print #line directives<br>
</div>
<pre><span id="VALdn_lval"><span class="keyword">val</span> dn_lval</span> : <code class="type">unit -> <a href="Cil.html#TYPElval">lval</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><pre><span id="VALdn_init"><span class="keyword">val</span> dn_init</span> : <code class="type">unit -> <a href="Cil.html#TYPEinit">init</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><pre><span id="VALdn_type"><span class="keyword">val</span> dn_type</span> : <code class="type">unit -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><pre><span id="VALdn_global"><span class="keyword">val</span> dn_global</span> : <code class="type">unit -> <a href="Cil.html#TYPEglobal">global</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><pre><span id="VALdn_attrlist"><span class="keyword">val</span> dn_attrlist</span> : <code class="type">unit -> <a href="Cil.html#TYPEattributes">attributes</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><pre><span id="VALdn_attr"><span class="keyword">val</span> dn_attr</span> : <code class="type">unit -> <a href="Cil.html#TYPEattribute">attribute</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><pre><span id="VALdn_attrparam"><span class="keyword">val</span> dn_attrparam</span> : <code class="type">unit -> <a href="Cil.html#TYPEattrparam">attrparam</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><pre><span id="VALdn_stmt"><span class="keyword">val</span> dn_stmt</span> : <code class="type">unit -> <a href="Cil.html#TYPEstmt">stmt</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><pre><span id="VALdn_instr"><span class="keyword">val</span> dn_instr</span> : <code class="type">unit -> <a href="Cil.html#TYPEinstr">instr</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><pre><span id="VALd_shortglobal"><span class="keyword">val</span> d_shortglobal</span> : <code class="type">unit -> <a href="Cil.html#TYPEglobal">global</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print a short description of the global. This is useful for error 
 messages<br>
</div>
<pre><span id="VALdumpGlobal"><span class="keyword">val</span> dumpGlobal</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> out_channel -> <a href="Cil.html#TYPEglobal">global</a> -> unit</code></pre><div class="info">
Pretty-print a global. Here you give the channel where the printout
 should be sent.<br>
</div>
<pre><span id="VALdumpFile"><span class="keyword">val</span> dumpFile</span> : <code class="type"><a href="Cil.cilPrinter-c.html">cilPrinter</a> -> out_channel -> string -> <a href="Cil.html#TYPEfile">file</a> -> unit</code></pre><div class="info">
Pretty-print an entire file. Here you give the channel where the printout
 should be sent.<br>
</div>
<br>
the following error message producing functions also print a location in 
 the code. use <a href="Errormsg.html#VALbug"><code class="code">Errormsg.bug</code></a> and <a href="Errormsg.html#VALunimp"><code class="code">Errormsg.unimp</code></a> if you do not want 
 that<br>
<pre><span id="VALbug"><span class="keyword">val</span> bug</span> : <code class="type">('a, unit, <a href="Pretty.html#TYPEdoc">Pretty.doc</a>) format -> 'a</code></pre><div class="info">
Like <a href="Errormsg.html#VALbug"><code class="code">Errormsg.bug</code></a> except that <a href="Cil.html#VALcurrentLoc"><code class="code">Cil.currentLoc</code></a> is also printed<br>
</div>
<pre><span id="VALunimp"><span class="keyword">val</span> unimp</span> : <code class="type">('a, unit, <a href="Pretty.html#TYPEdoc">Pretty.doc</a>) format -> 'a</code></pre><div class="info">
Like <a href="Errormsg.html#VALunimp"><code class="code">Errormsg.unimp</code></a> except that <a href="Cil.html#VALcurrentLoc"><code class="code">Cil.currentLoc</code></a>is also printed<br>
</div>
<pre><span id="VALerror"><span class="keyword">val</span> error</span> : <code class="type">('a, unit, <a href="Pretty.html#TYPEdoc">Pretty.doc</a>) format -> 'a</code></pre><div class="info">
Like <a href="Errormsg.html#VALerror"><code class="code">Errormsg.error</code></a> except that <a href="Cil.html#VALcurrentLoc"><code class="code">Cil.currentLoc</code></a> is also printed<br>
</div>
<pre><span id="VALerrorLoc"><span class="keyword">val</span> errorLoc</span> : <code class="type"><a href="Cil.html#TYPElocation">location</a> -> ('a, unit, <a href="Pretty.html#TYPEdoc">Pretty.doc</a>) format -> 'a</code></pre><div class="info">
Like <a href="Cil.html#VALerror"><code class="code">Cil.error</code></a> except that it explicitly takes a location argument, 
 instead of using the <a href="Cil.html#VALcurrentLoc"><code class="code">Cil.currentLoc</code></a><br>
</div>
<pre><span id="VALwarn"><span class="keyword">val</span> warn</span> : <code class="type">('a, unit, <a href="Pretty.html#TYPEdoc">Pretty.doc</a>) format -> 'a</code></pre><div class="info">
Like <a href="Errormsg.html#VALwarn"><code class="code">Errormsg.warn</code></a> except that <a href="Cil.html#VALcurrentLoc"><code class="code">Cil.currentLoc</code></a> is also printed<br>
</div>
<pre><span id="VALwarnOpt"><span class="keyword">val</span> warnOpt</span> : <code class="type">('a, unit, <a href="Pretty.html#TYPEdoc">Pretty.doc</a>) format -> 'a</code></pre><div class="info">
Like <a href="Errormsg.html#VALwarnOpt"><code class="code">Errormsg.warnOpt</code></a> except that <a href="Cil.html#VALcurrentLoc"><code class="code">Cil.currentLoc</code></a> is also printed. 
 This warning is printed only of <a href="Errormsg.html#VALwarnFlag"><code class="code">Errormsg.warnFlag</code></a> is set.<br>
</div>
<pre><span id="VALwarnContext"><span class="keyword">val</span> warnContext</span> : <code class="type">('a, unit, <a href="Pretty.html#TYPEdoc">Pretty.doc</a>) format -> 'a</code></pre><div class="info">
Like <a href="Errormsg.html#VALwarn"><code class="code">Errormsg.warn</code></a> except that <a href="Cil.html#VALcurrentLoc"><code class="code">Cil.currentLoc</code></a> and context 
    is also printed<br>
</div>
<pre><span id="VALwarnContextOpt"><span class="keyword">val</span> warnContextOpt</span> : <code class="type">('a, unit, <a href="Pretty.html#TYPEdoc">Pretty.doc</a>) format -> 'a</code></pre><div class="info">
Like <a href="Errormsg.html#VALwarn"><code class="code">Errormsg.warn</code></a> except that <a href="Cil.html#VALcurrentLoc"><code class="code">Cil.currentLoc</code></a> and context is also 
 printed. This warning is printed only of <a href="Errormsg.html#VALwarnFlag"><code class="code">Errormsg.warnFlag</code></a> is set.<br>
</div>
<pre><span id="VALwarnLoc"><span class="keyword">val</span> warnLoc</span> : <code class="type"><a href="Cil.html#TYPElocation">location</a> -> ('a, unit, <a href="Pretty.html#TYPEdoc">Pretty.doc</a>) format -> 'a</code></pre><div class="info">
Like <a href="Cil.html#VALwarn"><code class="code">Cil.warn</code></a> except that it explicitly takes a location argument, 
 instead of using the <a href="Cil.html#VALcurrentLoc"><code class="code">Cil.currentLoc</code></a><br>
</div>
<br>
Sometimes you do not want to see the syntactic sugar that the above 
 pretty-printing functions add. In that case you can use the following 
 pretty-printing functions. But note that the output of these functions is 
 not valid C<br>
<pre><span id="VALd_plainexp"><span class="keyword">val</span> d_plainexp</span> : <code class="type">unit -> <a href="Cil.html#TYPEexp">exp</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print the internal representation of an expression<br>
</div>
<pre><span id="VALd_plaininit"><span class="keyword">val</span> d_plaininit</span> : <code class="type">unit -> <a href="Cil.html#TYPEinit">init</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print the internal representation of an integer<br>
</div>
<pre><span id="VALd_plainlval"><span class="keyword">val</span> d_plainlval</span> : <code class="type">unit -> <a href="Cil.html#TYPElval">lval</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print the internal representation of an lvalue<br>
</div>
<br>
Pretty-print the internal representation of an lvalue offset 
val d_plainoffset: unit -&gt; offset -&gt; Pretty.doc<br>
<pre><span id="VALd_plaintype"><span class="keyword">val</span> d_plaintype</span> : <code class="type">unit -> <a href="Cil.html#TYPEtyp">typ</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print the internal representation of a type<br>
</div>
<pre><span id="VALdd_exp"><span class="keyword">val</span> dd_exp</span> : <code class="type">unit -> <a href="Cil.html#TYPEexp">exp</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-print an expression while printing descriptions rather than names
  of temporaries.
<p>
Pretty-print an lvalue on the left side of an assignment.
    If there is an offset or memory dereference, temporaries will
    be replaced by descriptions as in dd_exp.  If the lval is a temp var,
    that var will not be replaced by a description; use "dd_exp () (Lval lv)"
    if that's what you want.<br>
</div>
<pre><span id="VALdd_lval"><span class="keyword">val</span> dd_lval</span> : <code class="type">unit -> <a href="Cil.html#TYPElval">lval</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><br>
<b>ALPHA conversion</b> has been moved to the Alpha module.<br>
<pre><span id="VALuniqueVarNames"><span class="keyword">val</span> uniqueVarNames</span> : <code class="type"><a href="Cil.html#TYPEfile">file</a> -> unit</code></pre><div class="info">
Assign unique names to local variables. This might be necessary after you 
 transformed the code and added or renamed some new variables. Names are 
 not used by CIL internally, but once you print the file out the compiler 
 downstream might be confused. You might 
 have added a new global that happens to have the same name as a local in 
 some function. Rename the local to ensure that there would never be 
 confusioin. Or, viceversa, you might have added a local with a name that 
 conflicts with a global<br>
</div>
<br>
<b>Optimization Passes</b><br>
<pre><span id="VALpeepHole2"><span class="keyword">val</span> peepHole2</span> : <code class="type">(<a href="Cil.html#TYPEinstr">instr</a> * <a href="Cil.html#TYPEinstr">instr</a> -> <a href="Cil.html#TYPEinstr">instr</a> list option) -> <a href="Cil.html#TYPEstmt">stmt</a> list -> unit</code></pre><div class="info">
A peephole optimizer that processes two adjacent instructions and possibly 
    replaces them both. If some replacement happens, then the new instructions
    are themselves subject to optimization<br>
</div>
<pre><span id="VALpeepHole1"><span class="keyword">val</span> peepHole1</span> : <code class="type">(<a href="Cil.html#TYPEinstr">instr</a> -> <a href="Cil.html#TYPEinstr">instr</a> list option) -> <a href="Cil.html#TYPEstmt">stmt</a> list -> unit</code></pre><div class="info">
Similar to <code class="code">peepHole2</code> except that the optimization window consists of 
    one instruction, not two<br>
</div>
<br>
<b>Machine dependency</b><br>
<pre><span id="EXCEPTIONSizeOfError"><span class="keyword">exception</span> SizeOfError</span> <span class="keyword">of</span> <code class="type">string * <a href="Cil.html#TYPEtyp">typ</a></code></pre>
<div class="info">
Raised when one of the bitsSizeOf functions cannot compute the size of a 
 type. This can happen because the type contains array-length expressions 
 that we don't know how to compute or because it is a type whose size is 
 not defined (e.g. TFun or an undefined compinfo). The string is an 
 explanation of the error<br>
</div>
<pre><span id="VALunsignedVersionOf"><span class="keyword">val</span> unsignedVersionOf</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> <a href="Cil.html#TYPEikind">ikind</a></code></pre><div class="info">
Give the unsigned kind corresponding to any integer kind<br>
</div>
<pre><span id="VALsignedVersionOf"><span class="keyword">val</span> signedVersionOf</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> <a href="Cil.html#TYPEikind">ikind</a></code></pre><div class="info">
Give the signed kind corresponding to any integer kind<br>
</div>
<pre><span id="VALintRank"><span class="keyword">val</span> intRank</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> int</code></pre><div class="info">
Return the integer conversion rank of an integer kind<br>
</div>
<pre><span id="VALcommonIntKind"><span class="keyword">val</span> commonIntKind</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> <a href="Cil.html#TYPEikind">ikind</a> -> <a href="Cil.html#TYPEikind">ikind</a></code></pre><div class="info">
Return the common integer kind of the two integer arguments, as
    defined in ISO C 6.3.1.8 ("Usual arithmetic conversions")<br>
</div>
<pre><span id="VALintKindForSize"><span class="keyword">val</span> intKindForSize</span> : <code class="type">int -> bool -> <a href="Cil.html#TYPEikind">ikind</a></code></pre><div class="info">
The signed integer kind for a given size (unsigned if second argument
 is true). Raises Not_found if no such kind exists<br>
</div>
<pre><span id="VALfloatKindForSize"><span class="keyword">val</span> floatKindForSize</span> : <code class="type">int -> <a href="Cil.html#TYPEfkind">fkind</a></code></pre><div class="info">
The float kind for a given size. Raises Not_found
  if no such kind exists<br>
</div>
<pre><span id="VALbytesSizeOfInt"><span class="keyword">val</span> bytesSizeOfInt</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> int</code></pre><div class="info">
The size in bytes of the given int kind.<br>
</div>
<pre><span id="VALbitsSizeOf"><span class="keyword">val</span> bitsSizeOf</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> int</code></pre><div class="info">
The size of a type, in bits. Trailing padding is added for structs and 
 arrays. Raises <a href="Cil.html#EXCEPTIONSizeOfError"><code class="code">Cil.SizeOfError</code></a> when it cannot compute the size. This 
 function is architecture dependent, so you should only call this after you 
 call <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a>. Remember that on GCC sizeof(void) is 1!<br>
</div>
<pre><span id="VALtruncateCilint"><span class="keyword">val</span> truncateCilint</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> Cilint.cilint -> Cilint.cilint * Cilint.truncation</code></pre><div class="info">
Represents an integer as for a given kind.  Returns a truncation
 flag saying that the value fit in the kind (NoTruncation), didn't
 fit but no "interesting" bits (all-0 or all-1) were lost
 (ValueTruncation) or that bits were lost (BitTruncation). Another 
 way to look at the ValueTruncation result is that if you had used
 the kind of opposite signedness (e.g. IUInt rather than IInt), you
 would gave got NoTruncation...<br>
</div>
<pre><span id="VALfitsInInt"><span class="keyword">val</span> fitsInInt</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> Cilint.cilint -> bool</code></pre><div class="info">
True if the integer fits within the kind's range<br>
</div>
<pre><span id="VALintKindForValue"><span class="keyword">val</span> intKindForValue</span> : <code class="type">Cilint.cilint -> bool -> <a href="Cil.html#TYPEikind">ikind</a></code></pre><div class="info">
Return the smallest kind that will hold the integer's value.  The
 kind will be unsigned if the 2nd argument is true, signed
 otherwise.  Note that if the value doesn't fit in any of the
 available types, you will get ILongLong (2nd argument false) or
 IULongLong (2nd argument true).<br>
</div>
<pre><span id="VALmkCilint"><span class="keyword">val</span> mkCilint</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> int64 -> Cilint.cilint</code></pre><div class="info">
Construct a cilint from an integer kind and int64 value. Used for
 getting the actual constant value from a CInt64(n, ik, _)
 constant.<br>
</div>
<pre><span id="VALsizeOf"><span class="keyword">val</span> sizeOf</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
The size of a type, in bytes. Returns a constant expression or a
 "sizeof" expression if it cannot compute the size. This function
 is architecture dependent, so you should only call this after you
 call <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a>.<br>
</div>
<pre><span id="VALalignOf_int"><span class="keyword">val</span> alignOf_int</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> int</code></pre><div class="info">
The minimum alignment (in bytes) for a type. This function is 
 architecture dependent, so you should only call this after you call 
 <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a>.<br>
</div>
<pre><span id="VALbitsOffset"><span class="keyword">val</span> bitsOffset</span> : <code class="type"><a href="Cil.html#TYPEtyp">typ</a> -> <a href="Cil.html#TYPEoffset">offset</a> -> int * int</code></pre><div class="info">
Give a type of a base and an offset, returns the number of bits from the 
 base address and the width (also expressed in bits) for the subobject 
 denoted by the offset. Raises <a href="Cil.html#EXCEPTIONSizeOfError"><code class="code">Cil.SizeOfError</code></a> when it cannot compute 
 the size. This function is architecture dependent, so you should only call 
 this after you call <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a>.<br>
</div>
<pre><span id="VALchar_is_unsigned"><span class="keyword">val</span> char_is_unsigned</span> : <code class="type">bool ref</code></pre><div class="info">
Whether "char" is unsigned. Set after you call <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a><br>
</div>
<pre><span id="VALlittle_endian"><span class="keyword">val</span> little_endian</span> : <code class="type">bool ref</code></pre><div class="info">
Whether the machine is little endian. Set after you call <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a><br>
</div>
<pre><span id="VALunderscore_name"><span class="keyword">val</span> underscore_name</span> : <code class="type">bool ref</code></pre><div class="info">
Whether the compiler generates assembly labels by prepending "_" to the 
    identifier. That is, will function foo() have the label "foo", or "_foo"?
    Set after you call <a href="Cil.html#VALinitCIL"><code class="code">Cil.initCIL</code></a><br>
</div>
<pre><span id="VALlocUnknown"><span class="keyword">val</span> locUnknown</span> : <code class="type"><a href="Cil.html#TYPElocation">location</a></code></pre><div class="info">
Represents a location that cannot be determined<br>
</div>
<pre><span id="VALget_instrLoc"><span class="keyword">val</span> get_instrLoc</span> : <code class="type"><a href="Cil.html#TYPEinstr">instr</a> -> <a href="Cil.html#TYPElocation">location</a></code></pre><div class="info">
Return the location of an instruction<br>
</div>
<pre><span id="VALget_globalLoc"><span class="keyword">val</span> get_globalLoc</span> : <code class="type"><a href="Cil.html#TYPEglobal">global</a> -> <a href="Cil.html#TYPElocation">location</a></code></pre><div class="info">
Return the location of a global, or locUnknown<br>
</div>
<pre><span id="VALget_stmtLoc"><span class="keyword">val</span> get_stmtLoc</span> : <code class="type"><a href="Cil.html#TYPEstmtkind">stmtkind</a> -> <a href="Cil.html#TYPElocation">location</a></code></pre><div class="info">
Return the location of a statement, or locUnknown<br>
</div>
<pre><span id="VALdExp"><span class="keyword">val</span> dExp</span> : <code class="type"><a href="Pretty.html#TYPEdoc">Pretty.doc</a> -> <a href="Cil.html#TYPEexp">exp</a></code></pre><div class="info">
Generate an <a href="Cil.html#TYPEexp"><code class="code">Cil.exp</code></a> to be used in case of errors.<br>
</div>
<pre><span id="VALdInstr"><span class="keyword">val</span> dInstr</span> : <code class="type"><a href="Pretty.html#TYPEdoc">Pretty.doc</a> -> <a href="Cil.html#TYPElocation">location</a> -> <a href="Cil.html#TYPEinstr">instr</a></code></pre><div class="info">
Generate an <a href="Cil.html#TYPEinstr"><code class="code">Cil.instr</code></a> to be used in case of errors.<br>
</div>
<pre><span id="VALdGlobal"><span class="keyword">val</span> dGlobal</span> : <code class="type"><a href="Pretty.html#TYPEdoc">Pretty.doc</a> -> <a href="Cil.html#TYPElocation">location</a> -> <a href="Cil.html#TYPEglobal">global</a></code></pre><div class="info">
Generate a <a href="Cil.html#TYPEglobal"><code class="code">Cil.global</code></a> to be used in case of errors.<br>
</div>
<pre><span id="VALmapNoCopy"><span class="keyword">val</span> mapNoCopy</span> : <code class="type">('a -> 'a) -> 'a list -> 'a list</code></pre><div class="info">
Like map but try not to make a copy of the list<br>
</div>
<pre><span id="VALmapNoCopyList"><span class="keyword">val</span> mapNoCopyList</span> : <code class="type">('a -> 'a list) -> 'a list -> 'a list</code></pre><div class="info">
Like map but each call can return a list. Try not to make a copy of the 
    list<br>
</div>
<pre><span id="VALstartsWith"><span class="keyword">val</span> startsWith</span> : <code class="type">string -> string -> bool</code></pre><div class="info">
sm: return true if the first is a prefix of the second string<br>
</div>
<pre><span id="VALendsWith"><span class="keyword">val</span> endsWith</span> : <code class="type">string -> string -> bool</code></pre><div class="info">
return true if the first is a suffix of the second string<br>
</div>
<pre><span id="VALstripUnderscores"><span class="keyword">val</span> stripUnderscores</span> : <code class="type">string -> string</code></pre><div class="info">
If string has leading and trailing __, strip them.<br>
</div>
<br>
<b>An Interpreter for constructing CIL constructs</b><br>
<br><code><span id="TYPEformatArg"><span class="keyword">type</span> <code class="type"></code>formatArg</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fe</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Feo</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a> option</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >For array lengths</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fu</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEunop">unop</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fb</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEbinop">binop</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fk</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEikind">ikind</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FE</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEexp">exp</a> list</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >For arguments in a function call</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Ff</span> <span class="keyword">of</span> <code class="type">(string * <a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEattributes">attributes</a>)</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >For a formal argument</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FF</span> <span class="keyword">of</span> <code class="type">(string * <a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEattributes">attributes</a>) list</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >For formal argument lists</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fva</span> <span class="keyword">of</span> <code class="type">bool</code></code></td>
<td class="typefieldcomment" align="left" valign="top" ><code>(*</code></td><td class="typefieldcomment" align="left" valign="top" >For the ellipsis in a function type</td><td class="typefieldcomment" align="left" valign="bottom" ><code>*)</code></td>
</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fv</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEvarinfo">varinfo</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fl</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPElval">lval</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Flo</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPElval">lval</a> option</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fo</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEoffset">offset</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fc</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEcompinfo">compinfo</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fi</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEinstr">instr</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FI</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEinstr">instr</a> list</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Ft</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEtyp">typ</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fd</span> <span class="keyword">of</span> <code class="type">int</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fg</span> <span class="keyword">of</span> <code class="type">string</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fs</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEstmt">stmt</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FS</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEstmt">stmt</a> list</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FA</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattributes">attributes</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Fp</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattrparam">attrparam</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FP</span> <span class="keyword">of</span> <code class="type"><a href="Cil.html#TYPEattrparam">attrparam</a> list</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FX</span> <span class="keyword">of</span> <code class="type">string</code></code></td>

</tr></table>

<div class="info">
The type of argument for the interpreter<br>
</div>

<pre><span id="VALd_formatarg"><span class="keyword">val</span> d_formatarg</span> : <code class="type">unit -> <a href="Cil.html#TYPEformatArg">formatArg</a> -> <a href="Pretty.html#TYPEdoc">Pretty.doc</a></code></pre><div class="info">
Pretty-prints a format arg<br>
</div>
<pre><span id="VALwarnTruncate"><span class="keyword">val</span> warnTruncate</span> : <code class="type">bool ref</code></pre><div class="info">
Emit warnings when truncating integer constants (default true)<br>
</div>
<pre><span id="VALenvMachine"><span class="keyword">val</span> envMachine</span> : <code class="type">Machdep.mach option ref</code></pre><div class="info">
Machine model specified via CIL_MACHINE environment variable<br>
</div>
<pre><span id="VALconvertInts"><span class="keyword">val</span> convertInts</span> : <code class="type">int64 -> <a href="Cil.html#TYPEikind">ikind</a> -> int64 -> <a href="Cil.html#TYPEikind">ikind</a> -> int64 * int64 * <a href="Cil.html#TYPEikind">ikind</a></code></pre><div class="info">
<span class="warning">Deprecated.</span>. Convert two int64/kind pairs to a common int64/int64/kind triple.<br>
</div>
<pre><span id="VALisInteger"><span class="keyword">val</span> isInteger</span> : <code class="type"><a href="Cil.html#TYPEexp">exp</a> -> int64 option</code></pre><div class="info">
<span class="warning">Deprecated.</span>. Can't handle large 64-bit unsigned constants
    correctly - use getInteger instead. If the given expression
    is a (possibly cast'ed) character or an integer constant, return
    that integer.  Otherwise, return None.<br>
</div>
<pre><span id="VALtruncateInteger64"><span class="keyword">val</span> truncateInteger64</span> : <code class="type"><a href="Cil.html#TYPEikind">ikind</a> -> int64 -> int64 * bool</code></pre><div class="info">
<span class="warning">Deprecated.</span>. Use truncateCilint instead. Represents an integer as
 for a given kind.  Returns a flag saying whether the value was
 changed during truncation (because it was too large to fit in k).<br>
</div>
<pre><span id="VALgccBuiltins"><span class="keyword">val</span> gccBuiltins</span> : <code class="type">(string, <a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEtyp">typ</a> list * bool) Hashtbl.t</code></pre><div class="info">
<span class="warning">Deprecated.</span>.  For compatibility with older programs, these are
    aliases for <a href="Cil.html#VALbuiltinFunctions"><code class="code">Cil.builtinFunctions</code></a><br>
</div>
<pre><span id="VALmsvcBuiltins"><span class="keyword">val</span> msvcBuiltins</span> : <code class="type">(string, <a href="Cil.html#TYPEtyp">typ</a> * <a href="Cil.html#TYPEtyp">typ</a> list * bool) Hashtbl.t</code></pre><div class="info">
<span class="warning">Deprecated.</span>.  For compatibility with older programs, these are
  aliases for <a href="Cil.html#VALbuiltinFunctions"><code class="code">Cil.builtinFunctions</code></a><br>
</div>
</body></html>